动态规划 数位dp

概念
数位dp是一种计数用的dp，它的思考角度是从数字的每一个数位出发的，在每个数字的数位上进行dp（个位、十位、百位……）。

适用情况
一般就是给定一个闭区间 $[L,R]$ 让你求这个区间中满足 某种条件f(i) 的数字的个数。
条件 f(i) 一般与数的大小无关，而与数字的组成有关，由于数是按数位进行dp的，所以数字的值大小对复杂度的影响很小。（往往题目给的数字的数值会很大，但是数位的大小在不会TLE的范围内）

实现方法：记忆化搜索

我们用记忆化搜索，从数字的最高位开始搜索，知道末尾
我们用dp[][]数组来存储记忆化搜索获得的答案,记录的是合法的数字的个数。

对于题目给出的区间，用记忆化搜索去求解即可。

记忆化搜索函数有四个参数，四个参数分别为：当前的数位的下标，当前数位的上一个数位的数字，是否有上界限制的标记，是否有前导零的标记。

代码注释的很清楚了，直接看注释吧。

模板

#include<cstdio>
#include<iostream>
#include<cstdlib>
#include<cstring>
using namespace std;
const int maxn = 10;
const int INF = 0x3f3f3f3f;
int a[maxn];//存放数位的数组
int dp[maxn][maxn];//数位dp的dp数组是做记忆化搜索的记录用的，数位dp是要深搜的。
int dfs(int pos, int pre, bool limit, bool pre_zero)
{//pos为当前数位的下标，pre为pos的前一位数字、limit为是否有上界的标记、pre_zero为是否有前导零的标记。
    if(pos == 0)//如果我枚举到了下标为0的地方，说明已经枚举完了，因为我的数字的数位是存放在数组下标1~len的位置上
        return 1;
    if(!pre_zero && !limit && dp[pos][pre] != -1)//如果没有前导零，并且没有上界的限制，并且dp数组这一位有值(有值说明已经搜过了，记忆化记录了)，记得判断的顺序不要变换，这是为了避免判断dp数组的时候越界了。
        return dp[pos][pre];//那么我们就返回dp[pos][pre]

    int p, ret = 0;//p是是否含有前导零的标记，ret是return的缩写
    int up = limit ? a[pos] : 9;//上界，如果有限制，那么取a[pos]，否则没有上界限制，取9。
    for(int i = 0; i <= up; i++)//对于这个位上的数字，
    {
        if()//如果不符合条件，就直接忽略，继续枚举
            continue;
        //如果符合条件
        p = i;
        if(pre_zero && i == 0)//如果有前导零并且当前位为0，说明前面全是零。
            p = -INF;//-INF在这里是一个前导零的标记，数值上没有什么实际的意义。
        ret += dfs(pos - 1, p, limit & (i == up), p == -INF);//下标移向下一位。p是上一位数字。如果i等于up那么就有上界限制。如果p等于-INF，说明有前导零
    }
    if(!pre_zero && !limit)//如果没有前导零并且没有上界的限制
        dp[pos][pre] = ret;//记忆化存储
    return ret;
}
int bit(int num){//数位上的拆分
    int len = 0;//这个数字的长度
    while(num){
        a[++len] = num % 10;
        num /= 10;
    }
    memset(dp, -1, sizeof(dp));//dp初始化为-1，因为有可能某些情况下的方案数是0
    return dfs(len, -INF, true, true);//最高位的下标，上一位的数字（这里因为是最高位了，上一位数字不存在，所以设为-INF）
}
int main(){
    int n, m;
    while(scanf("%d %d", &n, &m) && (n || m)){
        printf("%d\n", bit(m) - bit(n - 1));
    }
    return 0;
}

例题
HDU - 2089 不要62 数位dp模板题
http://acm.hdu.edu.cn/showproblem.php?pid=2089

#include<cstdio>
#include<iostream>
#include<cstdlib>
#include<cstring>
using namespace std;
const int maxn = 10;
const int INF = 0x3f3f3f3f;
int a[maxn];//存放数位的数组
int dp[maxn][maxn];//数位dp的dp数组是做记忆化搜索的记录用的，数位dp是要深搜的。
int dfs(int pos, int pre, bool limit, bool pre_zero)
{//pos为当前数位的下标，pre为pos的前一位数字、limit为是否有上界的标记、pre_zero为是否有前导零的标记。
    if(pos == 0)//如果我枚举到了下标为0的地方，说明已经枚举完了，因为我的数字的数位是存放在数组下标1~len的位置上
        return 1;//为什么返回的是1?
    if(!pre_zero && !limit && dp[pos][pre] != -1)//如果没有前导零，并且没有上界的限制，并且dp数组这一位有值(有值说明已经搜过了，记忆化记录了)，记得判断的顺序不要变换，这是为了避免判断dp数组的时候越界了。
        return dp[pos][pre];//那么我们就返回dp[pos][pre]

    int p, ret = 0;//p是是否含有前导零的标记，ret是return的缩写
    int up = limit ? a[pos] : 9;//上界，如果有限制，那么取a[pos]，否则没有上界限制，取9。
    for(int i = 0; i <= up; i++)//对于这个位上的数字，
    {
        if(pre == 6 && i == 2)//如果不符合条件，就直接忽略，继续枚举
            continue;
        if(i == 4)
            continue;
        //如果符合条件
        p = i;
        if(pre_zero && i == 0)//如果有前导零并且当前位为0，说明前面全是零。
            p = -INF;//-INF在这里是一个前导零的标记，数值上没有什么实际的意义。
        ret += dfs(pos - 1, p, limit & (i == up), p == -INF);//下标移向下一位。p是上一位数字。如果i等于up那么就有上界限制。如果p等于-INF，说明有前导零
    }
    if(!pre_zero && !limit)//如果没有前导零并且没有上界的限制
        dp[pos][pre] = ret;//记忆化存储
    return ret;
}
int bit(int num)//数位上的拆分
{
    int len = 0;//这个数字的长度
    while(num){
        a[++len] = num % 10;
        num /= 10;
    }
    memset(dp, -1, sizeof(dp));//dp初始化为-1，因为有可能某些情况下的方案数是0
    return dfs(len, -INF, true, true);//最高位的下标，上一位的数字（这里因为是最高位了，上一位数字不存在，所以设为-INF）
}
int main(){
    int n, m;
    while(scanf("%d %d", &n, &m) && (n || m)){
        printf("%d\n", bit(m) - bit(n - 1));
    }
    return 0;
}

HDU - 3555 数位dp模板题
http://acm.hdu.edu.cn/showproblem.php?pid=3555

#include<cstdio>
#include<iostream>
#include<cstdlib>
#include<cstring>
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const ll maxn = 50;
ll a[maxn];
ll dp[maxn][maxn];
ll dfs(ll pos, ll pre, bool limit, bool pre_zero){
    if(pos == 0)
        return 1;
    if(!limit && !pre_zero && dp[pos][pre] != -1)
        return dp[pos][pre];
    ll p, ret = 0;
    ll up = limit ? a[pos] : 9;
    for(ll i = 0; i <= up; i++){
        if(pre == 4 && i == 9)
            continue;
        p = i;
        if(pre_zero && i == 0)
            p = -INF;
        ret += dfs(pos - 1, p, limit & (i == up), p == -INF);
    }
    if(!pre_zero && !limit)
        dp[pos][pre] = ret;
    return ret;
}
ll bit(ll num){
    ll len = 0;
    while(num){
        a[++len] = num % 10;
        num /= 10;
    }
    memset(dp, -1, sizeof(dp));
    return dfs(len, -INF, true, true);
}
int main()
{
    int t;
    ll n;
    scanf("%d", &t);
    while(t--){
        scanf("%lld", &n);
        printf("%lld\n", n - (bit(n) - bit(0)));
    }
    return 0;
}

参考来源

博客–推荐
https://walesexcitedmei.github.io/2018/10/30/%E6%B5%85%E6%B5%85%E6%B5%85%E8%B0%88-%E6%95%B0%E4%BD%8D-DP/
博客
https://www.luogu.org/blog/virus2017/shuweidp
OI wiki
https://oi-wiki.org/dp/number/