数位DP入门题

站点一览：

1. hdu 2089"不要62"
2. hdu 4734"F(X)"
3. poj 3252"Round Numbers"
4. hdu 3709"Balanced Number"

---

1.hdu 2089"不要62"

题解：

　　题目过于简单，不再赘述。

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))

int a,b;
int digit[10];
int dp[10][2];//dp[i][0]:位置i的前一个位置不为6的总方案数;dp[i][1]正好相反 

int DFS(int curPos,int preNum,int isSix,bool limit)
{
    if(curPos == -1)
        return 1;
    if(!limit && dp[curPos][isSix] != -1)
        return dp[curPos][isSix];
        
    int up=limit ? digit[curPos]:9;
    int ans=0;
    for(int i=0;i <= up;++i)
    {
        if((preNum == 6 && i == 2) || i == 4)
            continue;
         ans += DFS(curPos-1,i,i == 6,limit&& i == digit[curPos]);
    }
    if(!limit)
        dp[curPos][isSix]=ans;
    return ans;
}
int Solve(int x)
{
    int k=0;
    while(x)
    {
        digit[k++]=x%10;
        x /= 10;
    }
    return DFS(k-1,0,0,true);
}

int main()
{
    while(~scanf("%d%d",&a,&b) && a+b)
    {
        mem(dp,-1);
        printf("%d
",Solve(b)-Solve(a-1));
    }
    return 0;
}

---

2.hdu 4734"F(X)"

Problem Description
For a decimal number x with n digits (AnAn-1An-2 ... A2A1), we define its weight as F(x) = An * 2n-1 + An-1 * 2n-2 + ... + A2 * 2 + A1 * 1.
Now you are given two numbers A and B, please calculate how many numbers are there between 0 and B, inclusive, whose weight is no more than F(A).

Input
The first line has a number T (T <= 10000) , indicating the number of test cases.
For each test case, there are two numbers A and B (0 <= A,B < 109)

Output
For every case,you should output "Case #t: " at first, without quotes. The t is the case number starting from 1. Then output the answer.

题解：

　　初始想法：

　　定义dp[ i ][ j ] : [ 0,i ] 位置满足 weight == j 的数的总个数；

　　求出F(a)后，便利 i : 0~F(a) ，求出 [0,b] weight == i 的数的总个数，作加和；

　　很不幸，TLE，不过，还是挺开心的，毕竟是在看题解前按照自己的想法成功敲出的代码，虽然TLE了；

　　正解：定义dp[ i ][ j ] : [ 0,i ]位置满足 weight <= j 的数的总个数，然后，每次判断 dp[ i ][ j ]是否可以直接返回；

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))

int a,b;
int power[10]={1,2,4,8,16,32,64,128,256};
int digit[15];
int dp[15][30000];//dp[i][j]:前i位F值小于等于j的总个数

int F(int x)
{
    int sum=0;
    int base=1;
    while(x)
    {
        sum += (x%10)*base;
        base <<= 1;
        x /= 10;
    }
    return sum;
}
int DFS(int need,int curPos,int curSum,bool limit)
{
    if(curPos == -1)
        return curSum <= need ? 1:0;
        
    if(curSum > need)
        return 0;
        
    if(!limit&&dp[curPos][need-curSum] != -1)
        return dp[curPos][need-curSum];

    int up=limit ? digit[curPos]:9;
    int ans=0;
    for(int i=0;i <= up;++i)
        ans += DFS(need,curPos-1,curSum+i*power[curPos],limit&&i==digit[curPos]);
        
    if(!limit)
        dp[curPos][need-curSum]=ans;

    return ans;
}
int Solve(int x)
{
    int k=0;
    while(x)
    {
        digit[k++]=x%10;
        x /= 10;
    }
    int f=F(a);
    return DFS(f,k-1,0,true);
}
int main()
{
    int test;
    scanf("%d",&test);
    mem(dp,-1);
    for(int kase=1;kase <= test;++kase)
    {
        scanf("%d%d",&a,&b);
        printf("Case #%d: %d
",kase,Solve(b));
    }
    return 0;
}

---

3.poj 3252"Round Numbers"

题意：

　　输入两个十进制正整数a和b，求闭区间 [a ,b] 内有多少个Round number

　　所谓的Round Number就是把一个十进制数转换为一个无符号二进制数，若该二进制数中0的个数大于等于1的个数，则它就是一个Round Number

　　注意，转换所得的二进制数，最高位必然是1，最高位的前面不允许有0

题解：

　　定义dp[ i ][ j ][ k ] : 在没有限制的情况下，[0,i]位置满足 0 的个数等于 j，1 的个数等于 k 的数的总个数；

　　坑点：前导零不能算在 0 的总个数中；

因为poj炸了，所以一直处于wait状态，不过对拍了一下他人的AC代码，正确率是可以保证的，应该也不会超时吧orz；

wait代码：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))

int a,b;
int digit[35];
int dp[35][35][35];

//isSat:只有当出现第一个不为0的位数时才为true
//作用是去掉前导0的影响 
int DFS(int curPos,int totZero,int totOne,bool isSat,bool limit)
{
    if(curPos == -1)
        return totZero >= totOne;
        
    if(!limit && dp[curPos][totZero][totOne] != -1)
        return dp[curPos][totZero][totOne];
        
    int up=limit ? digit[curPos]:1;
    int ans=0;
    for(int i=0;i <= up;++i)
    {
        bool flag=(isSat || i != 0);
        ans += DFS(curPos-1,totZero+(flag&&i==0),totOne+(i==1),flag,limit&&i==digit[curPos]);
    }
    if(!limit)
        dp[curPos][totZero][totOne]=ans;
    return ans;
}
int Solve(int x)
{
    int k=0;
    while(x)
    {
        digit[k++]=x%2;
        x >>= 1;
    }    
    return DFS(k-1,0,0,false,true);
}
int main()
{
    mem(dp,-1);
    while(~scanf("%d%d",&a,&b))
        printf("%d
",Solve(b)-Solve(a-1));
        
    return 0;
}

---

4.hdu 3709"Balanced Number"

题意：

　　给一个很大的区间[x,y],(0 ≤ x ≤ y ≤ 10¹⁸).问：区间里面的数满足如下规则的有多少个？

　　规则：将数字放在天平上，天平能够平衡。天平的轴随意，力臂就是数字下标到天平轴的下标的距离。

题解：

　　脑海中浮现出如何记忆化搜索的代码，可就是没想到如何判断当前数是否为"balance number"，无奈之下，查阅大佬代码orz；

　　坑点：全为0的数会重复计算，需要减去重复的部分

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))

ll a,b;
int digit[20];
ll dp[20][20][1800];

//curSum:记录curPivot左边的和+右边的和，只有curSum == 0才能说明
// curPivot左边的和==右边的和 
ll DFS(int curPos,int curPivot,int curSum,bool limit)
{
    if(curPos == -1)
        return curSum == 0 ? 1:0;
    if(curSum < 0)
        return 0;
    if(!limit && dp[curPos][curPivot][curSum] != -1)
        return dp[curPos][curPivot][curSum];
        
    int up=limit ? digit[curPos]:9;
    ll ans=0;
    for(int i=0;i <= up;++i)
        ans += DFS(curPos-1,curPivot,curSum+i*(curPos-curPivot),limit&&i==digit[curPos]);
    
    if(!limit)
        dp[curPos][curPivot][curSum]=ans;
    return ans;
}
ll Solve(ll x)
{
    if(x == -1)
        return 0;
    int k=0;
    while(x)
    {
        digit[k++]=x%10;
        x /= 10;
    }
    ll ans=0;
    for(int i=k-1;i >= 0;--i)
        ans += DFS(k-1,i,0,true);
    return ans-k+1;
    //0个0,1个0,.......,(k-1)个0，全为0的情况被记录了k次,须减去(k-1)个重复的 
}
int main()
{
    int test;
    scanf("%d",&test);
    mem(dp,-1);
    while(test--)
    {
        scanf("%lld%lld",&a,&b);
        printf("%lld
",Solve(b)-Solve(a-1));
    }            
    return 0;
}