OJ---The 3n + 1 problem

Description

计算机科学中的问题往往被归纳为某一类问题（如NP问题，无法解决问题，递归等）。在这道问题中你将分析一种算法，它对所有可能的输入结果是未知的。

考虑以下算法：

   1. 输入n

   2. 输出n

   3. 如果n=1然后停止

   4. 如果n是奇数： n <-- n*3+1

   5. 其他的情况：   n <-- n/2

   6. 转向 2

例如：对于输入22，输出将会是22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1。据推测，该算法对于任何整数将终止于1。尽管算法很简单，目前还不清楚这一猜想是否正确。但是对于所有整数n(0<n<1,000,000)，已经过验证（事实上，符合规律的数比这还要多）。

对于给定的n，是有可能计算出该算法共输出了多少个数的，包括结尾的1，这个数叫做n的周期长度。在上面的例子中，22的周期长度是16。对于任何两个数字i和j，求出在i和j之间的数中，周期长度最大的那个数的周期长度。

Input

输入将包括一系列的整数对i和j，每行一对整数。所有整数将少于1000000 且大于0。你应该处理i和j（包括i,j） 之间的所有整数。可以假设，任何操作不会溢出32位整数。

Output

对于每一个对输入整数i和j，输出为i、j和最大周期长度。这三个数用空格分开，三个数在同一行，每两个数之间有一个空格。

Sample Input

1 10 100 200 201 210 900 1000

Sample Output

1 10 20 100 200 125 201 210 89 900 1000 174

HINT

应该把已经计算过的数的周期长度保存下来，超时的原因是已经计算过的周期长度的重复计算，

Append Code

#include <stdio.h>
#define MAX 1000005
int save[MAX]={0};//将数组定义为全局变量
int main ()
{
    int i,j,t,sum=0;
    int max=-1;
    while(scanf("%d %d",&i,&j)!=EOF)
    {
        int flag;
        int judge=0;
        if(i>j)
        {
            int q=i;
            i=j;
            j=q;
            judge=1;
        }
        for(t=i;t<=j;t++)
        {
            int m=t;
            while(1)
            {
               if(m==1) break;
               if(m%2==1) {m=m*3+1;sum++;}
               else {m=m/2;sum++;}
               if(m<1000005)//防止数组的越界访问
               if(save[m]!=0) {sum+=save[m];break;}//判断结果是否求过，节约时间
            }
            save[t]=sum;//将已经求出的结果存入数组
            sum=0;
        }
        max=0;
        for(int n=i;n<=j;n++)
        {
            if(save[n]>max) max=save[n];
        }
        if(judge)
        {
            int q=i;
            i=j;
            j=q;
        }
        printf("%d %d %d\n",i,j,max+1);
    }   
}

这道OJ上的作业题可谓困扰了我很久，做这道题的逻辑思路很简单，根据题目的提示可以意识到应该把求出的数据存入数组当中，即可大大缩短运算的时间。

但是问题的关键在于数组的定义，因为数组的长度超过了一百万，所以不能再定义为局部变量，因为局部变量存储在栈区中（Stack）,栈区的空间一般只有1~2Mb（可以说是相当小了，局部变量空间顶多放得下下524288个int类型），一百万长度的数组显然超过了默认的栈空间大小，所以会引起数组过大导致堆栈溢出的问题。

因此在定义较大数组是也要考虑内存分配的问题。

补充一点就是计算的中间值可能比一百万还要大，因此还应该要保证数组不会越界访问。