Analyzing Collatz-like sequences
Python 3, 269 254 252 246 bytes

d,m,i=eval(input())
S=set()
for n in range(1,1001):
 T=X=()
 while len(T)**3&lt;1e9&gt;=n:
  T=(n,)+T;n=[n//d,n*m+i][n%d&gt;0]
  if n in T:I=T.index;L=T[:I(n)+1];M=I(min(L));X=L[M:]+L[:M]
 S|={X}
for x in sorted(S):print(x and&quot;LOOP&quot;or&quot;DIVERGENT&quot;,*x[::-1])

(Now 10 times slower to save a few bytes. Typical code golf.)
Input a list via STDIN (e.g. [2, 3, 1]). I'm thinking that there's got to be a better way of standardising the cycles...
The approach is quite straightforward — test all 1000 numbers and take only the unique outputs. However, there are two little tricks in there:

Loops are represented by nonempty tuples, but more importantly divergence is represented by an empty tuple. This is good because:

It doesn't break sorted, and will even appear before all the loop tuples
It allows us to select a string via x and&quot;LOOP&quot;or&quot;DIVERGENT&quot;
*()[::-1] doesn't affect print


The loops are built backwards to turn &quot;sort ascending by last element&quot; into &quot;sort ascending by first element&quot;, which removes the need to pass a lambda into sorted.


Previous submission, 252 bytes
d,m,i=eval(input())
def f(n,T=()):
 x=[n//d,n*m+i][n%d&gt;0];I=T.index
 if x in T:L=T[:I(x)+1];M=I(min(L));return L[M:]+L[:M]
 return()if(T[1000:]or x&gt;1e9)else f(x,(x,)+T)
for x in sorted(set(map(f,range(1,1001)))):print(x and&quot;LOOP&quot;or&quot;DIVERGENT&quot;,*x[::-1])

This one's a lot faster.