Question

我不知道是什么事情...当我在我的电脑上运行时效果很好但是当我在uva提交它时说超出时限请帮助

#include <stdio.h>

int main（） {

long int i,j,c,t,k,u,r;
scanf("%d %d",&i,&j);
printf("%d %d",i,j);
r = 0;
if(i>j){
    t = i;
    i = j;
    j = t;
}
for(k = i; k<=j;k++){
    c = 1;
    u = k;
    while(u>1){
        if(u%2 == 0)
            u = u/2;
        else
            u = 3*u+1;
        c++;
        if(c>=r)
            r = c;
    }
}
printf (" %d",r);
return 0;

}

Answer 1

只是为了节省时间：

以下是加速I / O的好方法

#include <stdio.h>

void fastRead( size_t *a );
void fastWrite( size_t a );

inline void fastRead(size_t *a)
{
    int c=0;
    // note: 32 is space character
    while (c<33) c=getchar_unlocked();

    // initialize result value
    *a=0;

    // punctuation parens, etc are show stoppers
    while (c>47 && c<58)
    {
        *a = (*a)*10 + (size_t)(c-48);
        c=getchar_unlocked();
    }
    //printf( "%s, value: %lu\n", __func__, *a );
} // end function: fastRead


inline void fastWrite(size_t a)
{
    char snum[20];
    //printf( "%s, %lu\n", __func__, a );

    int i=0;
    do
    {
        // 48 is numeric character 0
        snum[i++] = (char)((a%10)+(size_t)48);
        a=a/10;
    }while(a>0);

    i=i-1; // correction for overincrement from prior 'while' loop

    while(i>=0)
    {
        putchar_unlocked(snum[i--]);
    }
    putchar_unlocked('\n');
} // end function: fastWrite

并通过以下方式输出字符：

putchar_unlocked( char );

并且在每个测试用例结束时总是有一个最后一行：

putchar_unlocked( '\n' );

输入一个字符串，在循环中调用以下内容直到遇到空格或换行符

char = getchar_unlocked()

以及最后的提示：使用size_t数值可以轻松解决大多数此类问题，这些值允许值为4gig或更高。（与unsigned long int相同）

针对当前的问题。一旦链计算出来，就可以将链保存在一个数组中，这样你就不必再计算它了。

你可以预先计算出第一个'x'链，例如前10个链，以帮助缩短执行时间。

Answer 2

以下代码，在我的ubuntu Linux 14.04上运行大约需要1秒钟，通过以下方式调用：

./untitled > outfile.txt

所以也许这可能有用。

注意：对于欧拉问题，必须对此进行大幅修改

注意：问题是＆＃34; UNDER＆＃34; 100万，但这段代码从1百万开始，而不是从999999开始

//  Longest Collatz sequence
// Problem 14

/*
 * criteria
 * The following iterative sequence is defined for the set of positive integers:
 *     n → n/2 (n is even)
 *     n → 3n + 1 (n is odd)
 *
 * example:
 * Using the rule above and starting with 13, we generate the following sequence:
 *     13 → 40 → 20 → 10 → 5 → 16 → 8 → 4 → 2 → 1
 * It can be seen that this sequence (starting at 13 and finishing at 1) contains 10 terms.
 * Although it has not been proved yet (Collatz Problem),
 * it is thought that all starting numbers finish at 1.
 *
 * the question:
 * Which starting number, under one million, produces the longest chain?
 *
 * Note:
 * Once the chain starts the terms are allowed to go above one million.
 */

#include <stdio.h>

// prototypes
void fastWrite( size_t a );



int main( void )
{
    #define MAX_START_VALUE (1000000)

    size_t LongestChain = 0;
    size_t LongestStartValue = 0;

    for( size_t i=MAX_START_VALUE; i; i--)
    {
        size_t chainLength = 0;
        size_t result = i;

        // for debug
        char buffer[] = "current start value:";
        for( size_t j=0; buffer[j]; j++) putchar_unlocked( buffer[j] );
        putchar_unlocked( ' ');
        fastWrite( i );
        // end debug

        while( result != 1 )
        {
            chainLength++;

            if( result&1 )
            { // then odd
                result = 3*result +1;
            }

            else
            { // else even
                result >>= 1;
            }

            // for debug
            //./fastWrite( result );
            // end debug
        }
        chainLength++;

        // for debug
        char buffer2[] = "chain length: ";
        for( size_t k=0; buffer2[k]; k++) putchar_unlocked( buffer2[k] );
        fastWrite( chainLength );
        putchar_unlocked( '\n' );
        // end debug

        if ( chainLength > LongestChain )
        {
            LongestChain = chainLength;
            LongestStartValue = i;
        }
    }



    fastWrite( LongestStartValue );
    putchar_unlocked('\n');
    //putchar_unlocked('\n');
} // end function: main


inline void fastWrite(size_t a)
{
    char snum[20];
    //printf( "%s, %lu\n", __func__, a );

    int i=0;
    do
    {
        // 48 is numeric character 0
        snum[i++] = (char)((a%10)+(size_t)48);
        a=a/10;
    }while(a>0);

    i=i-1; // correction for overincrement from prior 'while' loop

    while(i>=0)
    {
        putchar_unlocked(snum[i--]);
    }
    putchar_unlocked('\n');
} // end function: fastWrite

为何在uva在线超过3n + 1的时间限制

2 个答案: