Codeforces 914C Travelling Salesman and Special Numbers：数位dp

题目链接：http://codeforces.com/problemset/problem/914/C

题意：

　　对数字x进行一次操作，可以将数字x变为x在二进制下1的个数。

　　显然，一个正整数在进行了若干次操作后一定会变成1。

　　给定n,k（n用二进制表示给出，n <= 2^1000）。

　　问你有多少不超过n的正整数，将它们变为1所需的操作次数恰好为k。

题解：

　　由于n <= 2^1000，所以任何不超过n的数在进行了一次操作后，一定不超过1000。

　　所以先统计出1000以内所有数变成1所需的操作次数：f[i] = f[cal_bit(i)] + 1

　　那么最终答案 = ∑(恰好包含i个1，且不超过n的数字个数)，其中f[i] == k-1。

　　所以接下来就要求恰好包含i个1，且不超过n的数字个数：

　　　　表示状态：

　　　　　　dp[i][j][0/1]表示已经填了前i位数，用了j个1，是否与n匹配(0/1)，此时的方案数。

　　　　　　（n的最高位为第1位）

　　　　找出答案：

　　　　　　恰好包含i个1，且不超过n的数字个数 = dp[n][i][0] + dp[n][i][1]

　　　　如何转移：

　　　　　　对于dp[i][j][0]:

　　　　　　　　dp[i+1][j][0] += dp[i][j][0]

　　　　　　　　dp[i+1][j+1][0] += dp[i][j][0]

　　　　　　对于dp[i][j][1]:

　　　　　　　　如果n的第i+1位为1:

　　　　　　　　　　dp[i+1][j][0] += dp[i][j][1]

　　　　　　　　　　dp[i+1][j+1][1] += dp[i][j][1]

　　　　　　　　否则:

　　　　　　　　　　dp[i+1][j][1] += dp[i][j][1]

　　　　边界条件：

　　　　　　dp[1][0][0] = dp[1][1][1] = 1

 

　　　　最后统计下答案就好。

　　　　其中k==0或1的情况要特判。

AC Code:

#include <iostream>
#include <stdio.h>
#include <string.h>
#define MAX_N 1005
#define MOD 1000000007

using namespace std;

int n,k;
int ans=0;
int a[MAX_N];
int f[MAX_N];
int dp[MAX_N][MAX_N][2];
string s;

void read()
{
    cin>>s>>k;
    n=s.size();
    for(int i=0;i<n;i++) a[i+1]=s[i]-'0';
}

int cal_bit(int x)
{
    int cnt=0;
    int lowbit=x&-x;
    while(lowbit)
    {
        cnt++;
        x^=lowbit;
        lowbit=x&-x;
    }
    return cnt;
}

void cal_f()
{
    f[1]=0;
    for(int i=2;i<=1000;i++)
    {
        f[i]=f[cal_bit(i)]+1;
    }
}

void cal_dp()
{
    memset(dp,0,sizeof(dp));
    dp[1][0][0]=dp[1][1][1]=1;
    for(int i=1;i<n;i++)
    {
        for(int j=0;j<=i;j++)
        {
            if(dp[i][j][0])
            {
                dp[i+1][j][0]+=dp[i][j][0];
                dp[i+1][j+1][0]+=dp[i][j][0];
                dp[i+1][j][0]%=MOD;
                dp[i+1][j+1][0]%=MOD;
            }
            if(dp[i][j][1])
            {
                if(a[i+1])
                {
                    dp[i+1][j][0]+=dp[i][j][1];
                    dp[i+1][j+1][1]+=dp[i][j][1];
                    dp[i+1][j][0]%=MOD;
                    dp[i+1][j+1][1]%=MOD;
                }
                else
                {
                    dp[i+1][j][1]+=dp[i][j][1];
                    dp[i+1][j][1]%=MOD;
                }
            }
        }
    }
}

void cal_ans()
{
    for(int i=1;i<=1000;i++)
    {
        if(f[i]==k-1)
        {
            ans+=dp[n][i][0]+dp[n][i][1];
            ans%=MOD;
        }
    }
}

void work()
{
    if(k==0)
    {
        cout<<1<<endl;
        return;
    }
    cal_f();
    cal_dp();
    cal_ans();
    if(k==1) cout<<ans-1<<endl;
    else cout<<ans<<endl;
}

int main()
{
    read();
    work();
}