Question

100 - The 3n + 1问题 http://www.spoj.com/problems/PROBTRES/ 总是我得到这个＆gt;＆gt;＆gt;运行时错误（SIGSEGV）＆lt;＆lt;＆lt; 为什么PLZ帮忙！

背景：计算机科学中的问题通常被归类为属于某类问题（例如，NP，不可解决，递归）。在这个问题中，您将分析算法的属性，该算法的分类对于所有可能的输入都是未知的。

问题：

考虑以下算法：

1. input n

2. print n

3. if n = 1 then STOP

4. if n is odd then n = 3n + 1

5. else n = n / 2

6. GOTO 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，这称为n的循环长度。在上面的例子中，循环长度为22。

对于任何两个数字i和j，你要确定i和j之间所有数字的最大周期长度。

输入：输入将由一系列整数i和j组成，每行一对整数。所有整数都小于1,000,000且大于0。

您应该处理所有整数对，并且每对确定i和j之间所有整数的最大循环长度。

您可以假设没有操作溢出32位整数。

输出：对于每对输入整数i和j，您应该输出i，j和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





    #include <iostream>
    using namespace std ;
    long int a[1000001];

    long int F (long int n){
        if(a[n]!=0)
            return a[n];
        else {
            if(n%2 !=0)
                a[n]=F(n*3+1)+1 ; 
            else 
                a[n]=F(n/2)+1 ; 
            return a[n];
        }
    }
    int main(){
        a[1]= 1 ;
        long int i , j , MX , MN , x=0 ;
        while (cin>>i >> j ){
            MX=max(i,j);
            MN=min(i,j);
            for(;MN<=MX;MN++){
                if(x<F(MN))
                    x=F(MN) ; 
        }

        cout<<i<<" "<<j<<" "<<x<<endl; 
        x= 0; 
        }

        return 0 ;
    }

这和我的代码有什么区别？!!!

#include <stdio.h>
#include <stdlib.h>
#define MAX 1000001
static int result[MAX];
int calculate(unsigned long i);
int main()
{
    unsigned long int i = 0;
    unsigned long int j = 0;
    unsigned long int k = 0;
    int max,x,y;
    result[1] = result[0] = 1;
    while (scanf("%ld",&i)!= EOF)
    {
        scanf("%ld",&j);
        if (i > j)
        {
            x = i;
            y = j;
        }
        else
        {
            x = j;
            y = i;
        }
        max = 0;
        for (k = y; k <= x; k++)
        {
            if (result[k] != 0 && result[k] > max)
                max = result[k];
            else if (calculate(k) > max)
                max = result[k];
        }
        printf("%ld %\ld %d\n",i,j,max);
    }
    return 0;
}
int calculate(unsigned long i)
{
    if (i < MAX && result[i])
        return result[i];
    if ( i % 2 == 1 )
    {
        if (i < MAX)
            return  result[i] = 2+calculate((3*i+1)/2);
        else
            return 2+calculate((3*i+1)/2);
    }
    else
    {
        if( i < MAX)
            return result[i] = 1 + calculate(i / 2);
        else
            return 1 + calculate(i /2 );
    }
}

Answer 1

您可以查看n获得的实际值范围，因为它可能会跨越数组long a[1000001]。此外，您可能会检查您的递归深度。如果你太过深入，你就会溢出堆栈。

我会考虑添加一个断言来测试n（即assert(n < 1000001)），也许还有一个递归深度变量来检查递归深度，作为诊断和调试此代码的第一步。您可以在<cassert>中找到断言。

SIGSEGV＆＃34; 3n + 1＆＃34;

1 个答案: