数位DP初探

引言

数位DP的实质还是“枚举”，但利用记忆化搜索的方式使其具有DP的性质，从而降低了时间复杂度

基础

数位DP解决的问题一般类型是：统计一个区间[le,ri]内满足一些条件数的个数，如果暴力枚举即为：

int ans=0;
    for(int i=le;i<=ri;++i) 
        if(solve(i)) ans++;

可见当le，ri差值较大时（如>1e8），暴力枚举是行不通的。

数位DP“枚举”的思路大致就是：

按照一个数字位数的高低，由高到底进行处理、枚举，并根据不同的状态（题意）进行记忆化操作（关键）。
其中stata变量的转移最为重要，也是DP的精华所在。不同背景下，转移方程（分类转移等）和记忆化方式（数组维数等）是多变的。

模板

typedef long long ll;

int a[20];
ll dp[20][state];//不同题目状态不同

ll dfs(int pos,/*state 变量*/,bool lead,/*前导零*/,bool limit/*数位上界变量*/)
{
    //不是每个题都要判断前导零

    //递归边界，按位枚举，最低位是0，pos==-1说明这个数枚举完了
    if(pos==-1) return 1;/*这里一般返回1，表示枚举的这个数是合法的，
    这里就需要在枚举时必须每一位都要满足题目条件，也就是说当前枚举到pos位，
    一定要保证前面已经枚举的数位是合法的。具体题目不同或者写法不同的话不一定要返回1 */

    //可能需要剪枝

    if(!limit&&!lead &&dp[pos][state]!=-1)
        return dp[pos][state];//记忆化

    int up=limit?a[pos]:9;//确定枚举上界
    //注意要看limit，如果现在枚举的数是limited,则下一位枚举上界up可能不是9

    ll ans=0;//answer
    for(int i=0;i<=up;++i){//枚举，将不同的情况累加到ans上
        if()...
        else if()...
        ans+=dfs(pos-1,/*状态转移*/,lead&&i==0,limit&&i==a[pos])//最后两个变量形式一般不变
        /*这里一般变化较大
        大概是，当前枚举的数位是i,然后根据题目的约束条件分类讨论
        去计算不同情况下的个数，还要根据state变量来约束i使其合法
        比如题目要求数位上不能出现78连续，那么state变量可以保存当前位
        的前一位，然后分两类：前一位是7和前一位不是7，前一位是7时，后一位
        是8的数就不计了
        */
    }

    //计算完，记录状态
    if(!limit&&!lead) dp[pos][state]=ans;
    /*这里对应上面的记忆化，在一定条件下时记录，保证一致性，
    如果约束条件不需要考虑lead，这里就是lead就完全不用考虑了*/

    return ans;
}

ll solve(ll x)
{
    int pos=0;
    while(x)//得到数x的位数组,用于后面枚举
    {
        a[pos++]=x%10;//这里编号从1||0开始均可
        x/=10;
    }
    return dfs(pos-1,/*状态*/,true,true);//刚开始传参最高位都是有限制并且有前导零的，比最高位还要高的一位视为0
}

int main()
{
    int le,ri;
    while(scanf("%d %d",&le,&ri)&&le+ri)
    {
        memset(dp,-1,sizeof(dp));
        printf("%d\n",solve(ri)-solve(le-1));//“前缀和做法”
    }
    return 0;
}

例题  HD 2089

Problem Description

杭州人称那些傻乎乎粘嗒嗒的人为62（音：laoer）。
杭州交通管理局经常会扩充一些的士车牌照，新近出来一个好消息，以后上牌照，不再含有不吉利的数字了，这样一来，就可以消除个别的士司机和乘客的心理障碍，更安全地服务大众。
不吉利的数字为所有含有4或62的号码。例如：
62315 73418 88914
都属于不吉利号码。但是，61152虽然含有6和2，但不是62连号，所以不属于不吉利数字之列。
你的任务是，对于每次给出的一个牌照区间号，推断出交管局今次又要实际上给多少辆新的士车上牌照了。

 

Input

输入的都是整数对n、m（0<n≤m<1000000），如果遇到都是0的整数对，则输入结束。

 

Output

对于每个整数对，输出一个不含有不吉利数字的统计个数，该数值占一行位置。

 

Sample Input

  
  

   
   1 100
0 0
  
  

 

Sample Output

  
  

   
   80
  
  

代码示例

//#define LOCAL
#include<iostream>
#include<cstdio>
#include<math.h>
#include<string>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
using namespace std;

int a[20];
int dp[20][2];

int dfs(int pos,int pre,int sta,bool limit)
{
    if(pos==-1) return 1;
    if(!limit&&dp[pos][sta]!=-1) return dp[pos][sta];
    int up=limit?a[pos]:9;
    int tmp=0;
    for(int i=0;i<=up;++i){
        if(pre==6&&i==2) continue;
        if(i==4) continue;
        tmp+=dfs(pos-1,i,i==6,limit&&i==a[pos]);
    }
    if(!limit) dp[pos][sta]=tmp;
    return tmp;
}

int solve(int x)
{
    int pos=0;
    while(x)
    {
        a[pos++]=x%10;
        x/=10;
    }
    return dfs(pos-1,-1,0,true);
}


int main()
{
    #ifdef LOCAL
        freopen("read.txt","r",stdin);
    #endif
    int le,ri;
    memset(dp,-1,sizeof(dp));//考虑位置
    while(scanf("%d %d",&le,&ri)&&le+ri)
    {
        printf("%d\n",solve(ri)-solve(le-1));//“前缀和做法”
    }
    return 0;
}

一种更好理解的写法

#include<cstdio>

const int maxn=10;
long long f[maxn][10];

void getdp()
{
    f[0][0]=1;
    for (int i=1;i<10;i++)
    {
        for (int j=0;j<10;j++)
        {
            if (j==4) f[i][j]=0;
            else if (j==6)
            {
                for (int k=0;k<10;k++)
                    f[i][j]+=f[i-1][k];
                f[i][j]-=f[i-1][2];
            }
            else
            {
                for (int k=0;k<10;k++)
                    f[i][j]+=f[i-1][k];
            }
        }
    }
}

int a[maxn];
long long solve(int n)
{
    a[0]=0;
    while (n)
    {
        a[++a[0]]=n%10;
        n/=10;
    }
    a[a[0]+1]=0;
    long long ans=0;
    for (int i=a[0];i>=1;i--)
    {
        for (int j=0;j<a[i];j++)
            if (j!=4 && !(a[i+1]==6 && j==2))
                ans+=f[i][j];
        if (a[i]==4) break;
        if (a[i+1]==6 && a[i]==2) break;
    }
    return ans;
}

int main()
{
    int n,m;
    getdp();
    while (scanf("%d %d",&n,&m)==2 && (n||m))
    {
        long long k1=solve(m+1);
        long long k2=solve(n);
        //printf("::%d,%d::",k1,k2);
        printf("%I64d\n",k1-k2);
    }
    return 0;
}