HDU 1041 Computer Transformation（高精度）

Computer Transformation

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 3845    Accepted Submission(s): 1420

Problem Description

A sequence consisting of one digit, the number 1 is initially written into a computer. At each successive time step, the computer simultaneously tranforms each digit 0 into the sequence 1 0 and each digit 1 into the sequence 0 1. So, after the first time step, the sequence 0 1 is obtained; after the second, the sequence 1 0 0 1, after the third, the sequence 0 1 1 0 1 0 0 1 and so on.

How many pairs of consequitive zeroes will appear in the sequence after n steps?

 

 

Input

Every input line contains one natural number n (0 < n ≤1000).

 

 

Output

For each input n print the number of consecutive zeroes pairs that will appear in the sequence after n steps.

 

 

Sample Input

2 3

 

 

Sample Output

1 1

 

 

Source

Southeastern Europe 2005

 

 

Recommend

JGShining

 

 

先找到规律，推公式。

1->01 ,  0->10

 

而且很容易知道连续的0肯定是两个连续的0.

 

设f[n]为n步操作后连续0的个数

 

则连续的0怎么样来呢？只能由上一层的01变成，也就是上一层的01一定可以产生连续00

上一层的01可以由再上一层的1得到。或者由上一层的00也可以产生一个01.

所以递推公式产生了：

f[n]=f[n-2]+2^(n-3).

 

由这个递推公式很容易产生通项公式：

当n为偶数时，f[n]=(2^(n-1)+1)/3;

当n为奇数时，f[n]=(2^(n-1)-1)/3;

 

所有用大数公式就得出来了。。

 

用JAVA写大数写出来的。。

/*

 f[n]=f[n-2]+2^(n-3);

 

 

 

 n为奇数时，f[n]=(2^(n-1)-1)/3;

 n为偶数时，f[n]=(2^(n-1)+1)/3;

 

 

 

 */





import java.util.*;

import java.math.*;

import java.io.*;

public class Main {

    public static void main(String[] args) {

        Scanner cin=new Scanner(new BufferedInputStream(System.in));

        BigInteger a[]=new BigInteger[1000];

        a[0]=BigInteger.valueOf(1);

        for(int i=1;i<1000;i++)

            a[i]=a[i-1].multiply(BigInteger.valueOf(2));

        int n;

        BigInteger ans;

        while(cin.hasNextInt())

        {

             n=cin.nextInt();

             if(n%2==0)//偶数

             {

                 ans=a[n-1].add(BigInteger.valueOf(1));

                 ans=ans.divide(BigInteger.valueOf(3));

             }

             else

             {

                 ans=a[n-1].subtract(BigInteger.valueOf(1));

                 ans=ans.divide(BigInteger.valueOf(3));

             }

             System.out.println(ans);

        }



    }



}

 

 

 

import java.util.*;

import java.math.*;

import java.io.*;

public class Main {

    public static void main(String[] args) {

        int n;

        Scanner cin=new Scanner(new BufferedInputStream(System.in));

        BigInteger a=BigInteger.valueOf(2);

        BigInteger ans;

        while(cin.hasNextInt())

        {

            n=cin.nextInt();

            if(n%2==1)

              ans=a.pow(n-1).subtract(BigInteger.valueOf(1)).divide(BigInteger.valueOf(3));

            else

              ans=a.pow(n-1).add(BigInteger.valueOf(1)).divide(BigInteger.valueOf(3));

            System.out.println(ans);

        }



    }



}

 

 

辛辛苦苦C++写了用份string的高精度。。竟然超时了。。。。

 

效率不高