UVa Problem Solution: 100 - The 3n+1 problem

I originally used the straight forward method and got a RT of 1.250s. I believe that if I were using Java, I would get a TL. Thus, I switch to the method of precomputing all the cycle-lengths in range (0, 1000000).

Let a _l, a _l-1, ..., a ₁ donate the sequence generate by n = a _l whose cycle-length is l. We can use the following recurrence to accelerate the precomputing process:

    cycle-length (a_i) = cycle-length (a_i-1) + 1

Obviously,  we should follow a bottom-up manner to calculate cycle-lengths from a ₁ = 1. Here, we call a_i depends on a_i-1 if a_i-1 is the next element of a_i in the generated sequence. In fact, there will be two numbers that depend on n if n % 3 == 1 and (n-1)/3 % 2 == 1. Thus, the dependences form a tree-like structure and we should keep track of all of them.
 
However, some numbers in the generated sequence is too large to keep the cycle-lengths of them in the cycle-length table. In the following code, I just throw them away and recalculate them every time when needed. A more elegant way is keeping them in a hash table to save the recalculating time.
 
Code:

1. /*************************************************************************
2.  * Copyright (C) 2008 by liukaipeng                                      *
3.  * liukaipeng at gmail dot com                                           *
4.  *************************************************************************/
6. /* @JUDGE_ID 00000 100 C "The 3n+1 problem" */
8. #include <stdio.h>
9. #include <stdlib.h>
10. #include <string.h>
11. #include <strings.h>
13. #define MAX 1000000
15. /*************************************************************************
16.  * Queue (FIFO)                                                          *
17.  * Note: No error check is performed.                                    *
18.  *************************************************************************/
19. #define QUEUESIZE MAX
21. typedef size_t valuetype;
23. typedef struct queue {
24.   valuetype data[QUEUESIZE];
25.   int head;
26.   int tail;
27.   int size;
28. } queue;
30. void initqueue(queue *q) {
31.   q->head = 0;
32.   q->tail = 0;
33.   q->size = 0;
34. }
36. int emptyqueue(queue *q) {
37.   return q->size == 0;
38. }
40. void enqueue(queue *q, valuetype v) {
41.   q->data[q->tail++] = v;
42.   q->tail %= QUEUESIZE;
43.   q->size += 1;
44. }
46. valuetype dequeue(queue *q) {
47.   valuetype v = q->data[q->head++];
48.   q->head %= QUEUESIZE;
49.   q->size -= 1;
50.   return v;
51. }
52. /*************************************************************************/
54. int len[MAX] = {0};
55. queue q;
57. void fill()
58. {
59.   initqueue(&q);
60.   len[1] = 1;
61.   enqueue(&q, 1);
62.   for (; !emptyqueue(&q); ) {
63.     int cur = dequeue(&q);
64.     int pre;
65.     /* find the previous elements in the cycle */
66.     if (cur*2 < MAX) {
67.       pre = cur*2;
68.       len[pre] = len[cur] + 1;
69.       enqueue(&q, pre);
70.     }
71.     if (cur % 3 == 1 && (cur-1)/3 % 2 == 1 && (cur-1)/3 != 1) {
72.       pre = (cur-1)/3;
73.       len[pre] = len[cur] + 1;
74.       enqueue(&q, pre);
75.     }
76.   }
78.   {
79.     int i;
80.     for (i = 3; i < MAX; ++i) {
81.       if (len[i] == 0) {
82.         unsigned int j;
83.         int d;
84.         for (j = i, d = 0; j >= MAX || len[j] == 0; ++d) {
85.           if (j % 2 == 0)
86.             j = j/2;
87.           else
88.             j = 3*j+1;
89.         }
90.         len[i] = len[j] + d;
91.       }
92.     }
93.   }  
94. }
96. int main(int argc, char *argv[])
97. {
98. #ifndef ONLINE_JUDGE
99.   char in[256];
100.   char out[256];
101.   strcpy(in, argv[0]);
102.   strcat(in, ".in");
103.   freopen(in, "r", stdin);
104.   strcpy(out, argv[0]);
105.   strcat(out, ".out");
106.   freopen(out, "w", stdout);
107. #endif
109.   int i, j;
111.   fill();
112.   while (scanf("%d %d", &i, &j) != EOF) {
113.     int max = 0;
114.     printf("%d %d ", i, j);
115.     if (i > j) {
116.       i ^= j;
117.       j ^= i;
118.       i ^= j;
119.     }
120.     for (; i <= j; ++i)
121.       if (len[i] > max) 
122.         max = len[i];
123.     printf("%d/n", max);
124.   }
125.   return 0;
126. }
127.