不刷POJ了，没事刷刷UVa No.100

The 3n + 1 problem

Background

Problems in Computer Science are often classified as belonging to a certain class of problems (e.g., NP, Unsolvable, Recursive). In this problem you will be analyzing a property of an algorithm whose classification is not known for all possible inputs.

The Problem

Consider the following algorithm:

 
		1. 		 input n

		2. 		 print n

		3. 		 if n = 1 then STOP

		4. 		 		 if n is odd then   

		5. 		 		 else   

		6. 		 GOTO 2

Given the input 22, the following sequence of numbers will be printed 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1

It is conjectured that the algorithm above will terminate (when a 1 is printed) for any integral input value. Despite the simplicity of the algorithm, it is unknown whether this conjecture is true. It has been verified, however, for all integers n such that 0 < n < 1,000,000 (and, in fact, for many more numbers than this.)

Given an input n, it is possible to determine the number of numbers printed (including the 1). For a given nthis is called the cycle-length of n. In the example above, the cycle length of 22 is 16.

For any two numbers i and j you are to determine the maximum cycle length over all numbers between i and j.

The Input

The input will consist of a series of pairs of integers i and j, one pair of integers per line. All integers will be less than 1,000,000 and greater than 0.

You should process all pairs of integers and for each pair determine the maximum cycle length over all integers between and including i and j.

You can assume that no operation overflows a 32-bit integer.

The Output

For each pair of input integers i and j you should output i, j, and the maximum cycle length for integers between and including i and j. These three numbers should be separated by at least one space with all three numbers on one line and with one line of output for each line of input. The integers i and j must appear in the output in the same order in which they appeared in the input and should be followed by the maximum cycle length (on the same line).

Sample Input

1 10
100 200
201 210
900 1000

Sample Output

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

My Code
 


 
 

  
#include<iostream>

using namespace std;

unsigned int get_length(unsigned int i){
        unsigned int length = 0;
        while(i != 1 ){    
            if(i%2){
                 i = 3 * i + 1;
                 length++;
                 
            }else{
                 i /= 2;     
                 length++; 
            }
        }
        length++;
        return length;   
} 


int main(){
    
    unsigned int i, j, input_i, input_j;   
    unsigned int max_len;
    
    while(cin>>input_i>>input_j){
        max_len = 0;
        if( input_i > input_j){
            i = input_j;
            j = input_i;
        }else{
            j = input_j;
            i = input_i;       
        }             
        for(unsigned int m = i; m <= j; m++){
                  if(max_len < get_length(m)) max_len = get_length(m);
        }      
        cout<<input_i<<" "<<input_j<<" "<<max_len<<endl;
    }
      
    return 0;   
}  
  

  

  
Problem
 
 Verdict
Lang
Time
Best
Rank
Submit
 Time
discuss100 - The 3n + 1 problem
 Accepted
C++
0.559
0.000
11395
2
 mins ago
  

 
 

  

 
 

  这个代码写的还是比较水的，因为我注意到，很多数都有1,2,4,8,16,5,10,20,40,80,160,53这个序列，如果能发现某个数字在计算长度时候突然出现了之前的序列，剩下的直接加上后面的路径长度就好了。
  

  

  
但是这个代码怎么写效率高还没想好。
  

  

  
但是让我想起2012计算机综合的考研题（也是微软曾经的面试题），找出两个单向链表的公共部分。其实就是找出第一个公共节点，一旦有了第一个公共节点，后面的也就一样了。
  

  

  
这一道题的思路是先计算两条链表m,n的长度,分别是len_m, len_n。那么让链表长的一个（比如m长）指针(*pm)先走|len_m - len_n|个节点，然后两个指针同时后移，当他们第一次指向相同的节点时即为公共部分的头结点。