【思路，dp，BigInteger】ZOJ - 2598 Yet Another Digit

【redundant binary - 冗余二进制】：由0,1,2构成的二进制形式，基数还是2。

现给你一十进制数n，问其可转化成多少种冗余二进制形式。

首先要想到：2^x = 2*2^x-1 也就是说 10 <=> 02；20 <=> 12；

10000

-> 10000

-> 02000

-> 01200

-> 01120

-> 01112

从上面可以看出，第一位的1保持不变时，有1种冗余二进制形式；第一位的1变为0时，其后有多少个0存在，就有多少种冗余二进制形式；

从低位向高位看，每到一个1进行计算，记a为该位的1保持不变的方案数，b为该位的1变成0存在的方案数。记录该位1与上一位1之间连续0的个数。初始有a[0]=1，b[0]=0，c=0。

则（从低位向高位）第i个1保持不变的方案数a[i] =  上一位的1保持不变的方案数a[i-1] + 上一位的1变为0的方案数b[i-1]；

（从低位向高位）第i个1变为0的方案数b[i] =  上一位的1保持不变的方案数a[i-1]*c + 上一位的1变为0的方案数b[i-1]*(c+1)；

（注意此处的c+1,因为上一位1变成0后，该位1与上一个非零位之间会多出一个0来，即c+1个0；

举例说明：10100001

step1: 右边第1位为1，此时c=0;  a[1] =  a[0] + b[0] = 1；

　　　　　　　　　　　　　　　　（1010000）

　　　　　　　　　　　　　　　　b[1] =  a[0]*0 + b[0]*1 = 0；

step2: 右边第6位为1，此时c=4;  a[2] =  a[1] + b[1] = 1；

　　　　　　　　　　　　　　　　（10100001）-> a[1]

　　　　　　　　　　　　　　　　b[2] =  a[1]*4 + b[2]*5 = 4；

　　　　　　　　　　　　　　　　（100001）-> a[1]*4

　　　　　　　　　　　　　　　　（10001）

　　　　　　　　　　　　　　　　（1001）

　　　　　　　　　　　　　　　　（101）

step3: 右边第8位为1，此时c=1;  a[3] =  a[2] + b[2] = 5；

　　　　　　　　　　　　　　　　（000001） -> a[2]

　　　　　　　　　　　　　　　　（020001） -> b[2]

　　　　　　　　　　　　　　　　（012001）

　　　　　　　　　　　　　　　　（011201）

　　　　　　　　　　　　　　　　（011121）

　　　　　　　　　　　　　　　　b[3] =  a[2]*1 + b[2]*2 = 9；

　　　　　　　　　　　　　　　　（2100001） -> a[2]*1

　　　　　　　　　　　　　　　　（020001)   -> b[2]*2

　　　　　　　　　　　　　　　　（20001)

　　　　　　　　　　　　　　　　（012001)

　　　　　　　　　　　　　　　　（12001)

　　　　　　　　　　　　　　　　（011201)

　　　　　　　　　　　　　　　　（11201)

　　　　　　　　　　　　　　　　（011121)

　　　　　　　　　　　　　　　　（11121)

最后的答案就是a[n]+b[n]。

附代码：

 import java.math.BigInteger;
 import java.util.Scanner;

 public class Main {

     public static void main(String[] args) {
         // TODO Auto-generated method stub
         Scanner cin = new Scanner(System.in);

         while(cin.hasNext())
         {
             BigInteger n = cin.nextBigInteger();
             if (n.signum() < 0)  break;
             BigInteger a = BigInteger.ONE, b = BigInteger.ZERO;
             int c = 0;
             for(int i = 0; i < n.bitLength(); i++)
             {
                 if(n.testBit(i))
                 {
                     BigInteger a_ = a.add(b);
                     BigInteger b_ = a.multiply(BigInteger.valueOf(c)).add(b.multiply(BigInteger.valueOf(c+1)));
                     c = 0;
                     a = a_;
                     b = b_;
                 }
                 else
                     c++;
             }
             System.out.println(a.add(b));
         }
         cin.close();
     }
 }