扩展二进制数

扩展二进制数

我们都知道二进制数的每一位可以是0或1。有一天小Hi突发奇想：如果允许使用数字2会发生什么事情？小Hi称其为扩展二进制数，例如(21)ii = 2 * 21 + 1 = 5, (112)ii = 1 * 22 + 1 * 21 + 2 = 8。

很快小Hi意识到在扩展二进制中，每个数的表示方法不是唯一的。例如8还可以有(1000)ii, (200)ii, (120)ii 三种表示方法。

对于一个给定的十进制数 N ，小Hi希望知道它的扩展二进制表示有几种方法？ 

输入

一个十进制整数 N。(0 ≤ N ≤ 1000000000) 

输出

N的扩展二进制表示数目。

——————————————————————————————————————分割——————————————————————————————————————

这一题，我首先想到的是dfs，实际上dfs是最慢的，而且很容易栈溢出，实时证明确实超时了，而且还是在时间足够的情况下，羞愧难当。但是先贴代码吧。

int factor[100000] = {0};
int Hash[20] = {0};

int k = 0;
int cnt = 0;

void dfs(int index, long n, int sum){
    if(sum>n || index == k){
        return;
    }
    if(sum == n){
        cnt++;
        return;
    }
   
    if(Hash[index] == 2){
        for(int i = index+1; i<k;i++){
            Hash[i] ++;
            dfs(i, n, sum+factor[i]);
            Hash[i] --;
        }
    }
    else{
        for(int i = index; i<k;i++){
            Hash[i] ++;
            dfs(i, n, sum+factor[i]);
            Hash[i] --;
        }
    }
}


int main(){
    long n;
    cin>>n;
       while(pow(2, k) <= n){
        factor[k] = pow(2, k);
        k++;
    }
    dfs(0, n, 0);
    cout<<cnt;
    return 0;
}

（写的也很长），讨论区给了两种做法，其实都可以用dp化简。

1、从最高位开始

在递归函数中，判断最高位是不是1，若是1，则分两种情况：一是将最高位给down到后几位；二是最高位不变。这样递归到最后，然后将两种情况合并，最后就可以输出。

注意：当上一位是1，并且需要down的时候，若当前位为1，则表示接受上一位之后肯定超过了2，那么肯定会有一位down到后面一位（ps. 永远不能down两位下来，因为这样即使后面几位全为1也消化不了）

贴代码吧：

int num[10000] = {0};
int k = 0;

void init(long n){
    if(n == 0) return;
    else{
        num[k++] = n%2;
        init(n/2);
    }
}

int down(int index, int n){
    if(index == 0){
        if(num[index] == 1 && n == 1) return 0;
        else return 1;
    }
    
    int temp = num[index] + n*2;
    if(temp == 3) return down(index-1, 1);
    else if(temp == 1 || temp == 2) return down(index-1, 0) + down(index-1, 1);
    else return down(index-1, 0);
}

int main(){
    long n;
    cin>>n;
    init(n);
    cout<<down(k-1, 0)<<endl;
}

2、从最低位开始

将其二进制之后，观察最后一位是否为1：

1、若为1则表示无法接受上一位的down，这样就直接再计算除去最后一位的二进制数的可能解；

2、若不为1（0），则表示可以接受上一位的down，这样就分两种情况：接受上一位的down + 不接受

int up(long n){
    if(n == 0 || n == 1) return 1;
    if(n % 2 == 1) return up(n/2);
    else return up(n/2) + up(n/2-1);
}

int main(){
    long n; cin>>n;
    cout<<up(n);
    return 0;
}

接下来是用dp解决，不知道算不算伪dp，但是速度肯定是快很多，毕竟还是用空间解决了时间问题：

int num[10000] = {0};
int k = 0;
int dp[10000][10] = {0};

void init(long n){
    if(n == 0) return;
    else{
        num[k++] = n%2;
        init(n/2);
    }
}

int down(int index, int la){
    if(dp[index][la] != 0) return dp[index][la];
    if(index == 0){
        if(num[index] == 1 && la == 1) {dp[index][la] = 0; return 0;}
        else {
            dp[index][la] = 1;
            return 1;
        }
    }
    int temp = num[index] + la*2;
    if(temp == 3) {
        dp[index][la] = down(index-1, 1);
        return dp[index][la];
    }
    else if(temp == 1 || temp == 2) {
        dp[index][la] = down(index-1, 0) + down(index-1, 1);
        return dp[index][la];
    }
    else {
        dp[index][la] = down(index-1, 0);
        return dp[index][la];
    }
}

int main(){
    int n; cin>>n;
    init(n);
    cout<<down(k-1, 0);
    return 0;
}

lz终于放弃javaweb了，spring配置起来繁琐至极，听说springboot会好很多，但是才学了一般hibernate就觉得很无聊，于是就直接转学python+ML，学了两天还在兴趣阶段，觉得有意思。

也是很不容易啊，上次的PAT考了91，很不满意啊，但是也没办法了，最后一题不知道哪里有问题，红黑树的判断很简单才对啊。