数位dp小结

数位dp如何入门

我最初在网上漫游了一天，终于找到了一个适合自己的学习方式，这里分享给大家。搜数位dp大部分都是记忆化搜索写的，因为这个搜索是反向的，所以一看是看上去真的什么都看不懂，因此我们首先学一下递推版的，这里给出网址，大家可以去看一下写的真的很好，认真看就能看明白初探数位dp，然后看懂了之后就手写代码，通常写hdu2089（不要62）这个入门题，这样我们就可以开始看记忆化搜索了，只是反向而已，那么既然有正推为什么还要学记忆化，首先学会之后比较好学，然后就是记忆化其实真的不难，学会之后很好处理。

给出记忆化的模板：
摘自Beginner

//    pos    = 当前处理的位置(一般从高位到低位)
//    pre    = 上一个位的数字(更高的那一位)
//    status = 要达到的状态,如果为1则可以认为找到了答案,到时候用来返回,
//         　　 给计数器+1。
//    limit  = 是否受限,也即当前处理这位能否随便取值。如567,当前处理6这位,
//         　　 如果前面取的是4,则当前这位可以取0-9。如果前面取的5,那么当前
//         　　 这位就不能随便取，不然会超出这个数的范围,所以如果前面取5的
//         　　 话此时的limit=1,也就是说当前只可以取0-6。
//
//    用DP数组保存这三个状态是因为往后转移的时候会遇到很多重复的情况。
int    dfs(int pos,int pre,int status,int limit)
{
    //已结搜到尽头,返回"是否找到了答案"这个状态。
    if(pos < 1)
        return    status;

    //DP里保存的是完整的,也即不受限的答案,所以如果满足的话,可以直接返回。
    if(!limit && DP[pos][pre][status] != -1)
        return    DP[pos][pre][status];

    int    end = limit ? DIG[pos] : 9;
    int    ret = 0;

    //往下搜的状态表示的很巧妙,status用||是因为如果前面找到了答案那么后面
    //还有没有答案都无所谓了。而limti用&&是因为只有前面受限、当前受限才能
    //推出下一步也受限，比如567,如果是46X的情况,虽然6已经到尽头,但是后面的
    //个位仍然可以随便取,因为百位没受限,所以如果个位要受限,那么前面必须是56。
    //
    //这里用"不要49"一题来做例子。
    for(int i = 0;i <= end;i ++)
        ret += dfs(pos - 1,i,status || (pre == 4 && i == 9),limit && (i == end));

    //DP里保存完整的、取到尽头的数据
    if(!limit)
        DP[pos][pre][status] = ret;

    return    ret;
}

这里是我自己写的几道练手题：

hdu 2089 不要62

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
const int maxn = 35;
LL dp[maxn][10][2],bit[maxn];

LL dfs(int pos,int pre,int is,int f){
    if(pos < 1) return is;
    if(!f && dp[pos][pre][is] != -1) return dp[pos][pre][is];
        int last = f?bit[pos]:9;
    LL res = 0;
    for(int i = 0; i <= last; i++){
        res += dfs(pos-1, i, is||(pre == 4 && i == 9), f&&i==last);
    }
    if(!f) dp[pos][pre][is] = res;
    return res;
}

LL solve(LL n){
    int len = 0;
    while(n){
        bit[++len] = n%10;
        n /= 10;
    }
    return dfs(len, 0, 0, 1);  //当前的位置,前一个数是多少，该书中是否已经含有49,f我不知道什么意思
}

int main(){
    int T;
    scanf("%d", &T);
    while(T--){
        LL n;
        scanf("I64d", &n);
        printf("%I64d\n", solve(n));
    }
    return ;
}

hdu 3555 bomb

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
const int maxn = 35;
LL dp[maxn][10][2],digit[maxn];

LL dfs(int pos,int pre,int is,int limit){  //limit表示是否有限制
    if(pos < 1) return is;  //是否有49
    if(!limit && dp[pos][pre][is] != -1) return dp[pos][pre][is];
    int last = limit ? digit[pos]:9;  //f用来判断是否能随意取
    LL ret = 0;
    for(int i = 0; i <= last; i++)
        ret += dfs(pos-1, i, is||(pre==4 && i==9), limit&&i==last);
    if(!limit) dp[pos][pre][is] = ret;
    return ret;
}

LL solve(LL n){
    int len = 0;
    memset(digit, 0, sizeof(digit));
    while(n){
        digit[++len] = n%10;
        n /= 10;
    }
    return dfs(len, 0, 0, 1);
}

int main(){
    int T;
    scanf("%d", &T);
    memset(dp, -1, sizeof(dp));
    while(T--){
        LL n;
        scanf("%I64d", &n);
        printf("%I64d\n", solve(n));
    }
    return 0;
}

hdu 4722 Good Numbers

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
const int MOD = 10;
const int maxn = 25;
LL dp[maxn][15],dig[maxn];

LL dfs(int pos, int mod, int limit){
    if(pos < 1) return mod == 0;
    if(!limit && dp[pos][mod] != -1) return dp[pos][mod];
    int len = limit?dig[pos]:9;
    LL ret = 0;
    for(int i = 0; i <= len; i++)
        ret += dfs(pos-1, (mod+i)%MOD, limit&&i==len);
    if(!limit) dp[pos][mod] = ret;
    return ret;
}

LL solve(LL n){
    LL len = 0;
    while(n){
        dig[++len] = n%10;
        n /= 10;
    }
    return dfs(len, 0, 1);
}

int main(){
    int T;
    scanf("%d", &T);
    LL A,B;
    memset(dp, -1, sizeof(dp));
    for(int kase = 1; kase <= T; kase++){
        scanf("%I64d%I64d", &A, &B);
        printf("Case #%d: ", kase);
        if(A == 0) printf("%I64d\n", solve(B));  //注意A取0，那么A-1小于0，不合理，因此需要特判
        else printf("%I64d\n", solve(B) - solve(A-1));
    }
    return 0;
}