数位dp

首先我们要清楚数位dp解决的是什么问题：

求出在给定区间 [A,B] 内，符合条件 f(i) 的数 i 的个数。条件 f(i) 一般与数的大小无关，而与数的组成有关。
这里我们使用记忆化搜索实现数位dp。本质上记搜其实就是dp，下文会重点介绍dp值的使用和记录

记搜过程

从起点向下搜索，到最底层得到方案数，一层一层向上返回答案并累加，最后从搜索起点得到最终答案。

对于 [l,r] 区间问题，我们一般把他转化为两次数位dp,即找 [0,r] 和 [0,l-1] 两段，再将结果相减就得到了我们需要的 [l,r]
【细节分析】

一、前导0标记lead

由于我们要搜的数可能很长，所以我们的直接最高位搜起

举个例子：假如我们要从 [0,1000] 找任意相邻两数相等的数

显然 111,222,888 等等是符合题意的数

但是我们发现右端点 1000 是四位数

因此我们搜索的起点是 0000 ，而三位数的记录都是 0111,0222,0888 等等

而这种情况下如果我们直接找相邻位相等则 0000 符合题意而 0111,0222,0888 都不符合题意了

所以我们要加一个前导0标记

如果当前位 lead=1 而且当前位也是0，那么当前位也是前导0， pos+1 继续搜；
如果当前位 lead=1 但当前位不是0，则本位作为当前数的最高位， pos+1 继续搜；（注意这次根据题意st或其他参数可能发生变化）

如果当前位 lead=1 而且当前位也是0，那么当前位也是前导0， pos+1 继续搜；
如果当前位 lead=1 但当前位不是0，则本位作为当前数的最高位， pos+1 继续搜；（注意这次根据题意st或其他参数可能发生变化）

当然前导 0 有时候是不需要判断的，上述的例子是一个有关数字结构上的性质，0会影响数字的结构，所以必须判断前导0；而如果我们研究的是数字的组成（例如这个数字有多少个 1 之类的问题），0并不影响我们的判断，这样就不需要前导0标记了。总之，这个因题而异，并不是必须要标记（当然记了肯定是不会出错的）

二、最高位标记limit

我们知道在搜索的数位搜索范围可能发生变化；

举个例子：我们在搜索 [0,555] 的数时，显然最高位搜索范围是 0 ~ 5 ，而后面的位数的取值范围会根据上一位发生变化：

当最高位是 1 ~ 4 时，第二位取值为 [0,9] ;
当最高位是 5 时，第二位取值为 [0,5] （再往上取就超出右端点范围了）

当最高位是 1 ~ 4 时，第二位取值为 [0,9] ;
当最高位是 5 时，第二位取值为 [0,5] （再往上取就超出右端点范围了）

为了分清这两种情况，我们引入了 limit 标记：

若当前位 limit=1 而且已经取到了能取到的最高位时，下一位 limit=1 ；
若当前位 limit=1 但是没有取到能取到的最高位时，下一位 limit=0 ；
若当前位 limit=0 时，下一位 limit=0 。

若当前位 limit=1 而且已经取到了能取到的最高位时，下一位 limit=1 ；
若当前位 limit=1 但是没有取到能取到的最高位时，下一位 limit=0 ；
若当前位 limit=0 时，下一位 limit=0 。

我们设这一位的标记为 limit ，这一位能取到的最大值为 res ，则下一位的标记就是 i==res && limit （i 枚举这一位填的数）

代码模板

typedef long long ll;
int a[20];
ll dp[20][state];//不同题目状态不同
//一搬情况下这里的lead变量是不需要的，要根据题意确定
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判断枚举的上界up;这个的例子前面用213讲过了
    ll ans=0;
    //开始计数
    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的合法性，比如题目
        要求数位上不能有62连续出现,那么就是state就是要保存前一位pre,然后分类，
        前一位如果是6那么这意味就不能是2，这里一定要保存枚举的这个数是合法*/
    }
    //计算完，记录状态
    if(!limit && !lead) dp[pos][state]=ans;
    /*这里对应上面的记忆化，在一定条件下时记录，保证一致性，当然如果约束条件不需要考虑lead，这里就是lead就完全不用考虑了*/
    return ans;
}
ll solve(ll x)
{
    int pos=0;
    while(x)//把数位都分解出来
    {
        a[pos++]=x%10;//个人老是喜欢编号为[0,pos),看不惯的就按自己习惯来，反正注意数位边界就行
        x/=10;
    }
    return dfs(pos-1/*从最高位开始枚举*/,/*一系列状态 */,true,true);//刚开始最高位都是有限制并且有前导零的，显然比最高位还要高的一位视为0嘛
}
int main()
{
    ll le,ri;
    while(~scanf("%lld%lld",&le,&ri))
    {
        //初始化dp数组为-1,这里还有更加优美的优化,后面讲
        printf("%lld\n",solve(ri)-solve(le-1));
    }
}

例题

入门题。就是数位上不能有4也不能有连续的62，没有4的话在枚举的时候判断一下，不枚举4就可以保证状态合法了，所以这个约束没有记忆化的必要，而对于62的话，涉及到两位，当前一位是6或者不是6这两种不同情况我计数是不相同的，所以要用状态来记录不同的方案数。

dp[pos][sta]表示当前第pos位，前一位是否是6的状态，这里sta只需要去0和1两种状态就可以了，不是6的情况可视为同种，不会影响计数。

我自己的代码

#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
using namespace std;
const int maxn=1e5+10;
typedef long long ll;
int n,m;
int a[30],dp[20][2];
//第pos位state是由数字前几位决定的； 
//dp[pos][state]表示第pos位他前面状态是state时数字的个数；
//dp[pos][state]存的是前一位没有限制时的个数 
int dfs(int pos,int pre,int state,bool limit)
{
	if(pos==-1) return 1;
	
	if(!limit&&dp[pos][state]!=-1)
	{
		return dp[pos][state];
	}
	
	int up=limit? a[pos] : 9;
	int tmp=0;
	for(int i=0;i<=up;i++)
	{
		//如果有其他要派出的，多传几位pre,排除一下就好了 
		if(i==4) continue;
		if(i==2&&pre==6) continue;
		
		//这里是为了确定下一个的状态值 
		if(i==6)
		{
			tmp+=dfs(pos-1,i,1,limit&&a[pos]==i);
		}
		else
		{
			tmp+=dfs(pos-1,i,0,limit&&a[pos]==i);
		}		
		
	}
	if(!limit) dp[pos][state]=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(){
	
		while(cin>>n>>m,n+m)
		{			
			fill(dp[0],dp[0]+20*2,-1);
			int k=solve(m)-solve(n-1);
			cout<<k<<endl;
		}
		

	
}

别人的代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
using namespace std;
typedef long long ll;
int a[20];
int dp[20][2];
//dp[pos][sta]表示前一位sta状态下这一位及之后的数位构成的所有可能
//这里sta的值是0/1，用来区分pre是不是6
//limit用来判断是不是数位上界，是则本位不能取到大于a[pos]的数
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()
{
    int le,ri;
    //memset(dp,-1,sizeof dp);可优化
    while(~scanf("%d%d",&le,&ri) && le+ri)
    {
        memset(dp,-1,sizeof dp);
        printf("%d\n",solve(ri)-solve(le-1));
    }
    return 0;
}

找出1~n范围内含有13并且能被13整除的数字的个数

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;

int bit[15];
int dp[15][15][3];
//dp[i][j][k]
//i:数位
//j:余数
//k:3种操作状况，0：末尾不是1,1：末尾是1,2：含有13

int dfs(int pos,int mod,int have,int lim)//lim记录上限
{
    int num,i,ans,mod_x,have_x;
    if(pos<=0)
        return mod == 0 && have == 2;
    if(!lim && dp[pos][mod][have] != -1)//没有上限并且已被访问过
        return dp[pos][mod][have];
    num = lim?bit[pos]:9;//假设该位是2，下一位是3，如果现在算到该位为1，那么下一位是能取到9的，如果该位为2，下一位只能取到3
    ans = 0;
    for(i = 0; i<=num; i++)
    {
        mod_x = (mod*10+i)%13;//看是否能整除13，而且由于是从原来数字最高位开始算，细心的同学可以发现，事实上这个过程就是一个除法过程
        have_x = have;
        if(have == 0 && i == 1)//末尾不是1，现在加入的是1
            have_x = 1;//标记为末尾是1
        if(have == 1 && i != 1)//末尾是1，现在加入的不是1
            have_x = 0;//标记为末尾不是1
        if(have == 1 && i == 3)//末尾是1，现在加入的是3
            have_x = 2;//标记为含有13
        ans+=dfs(pos-1,mod_x,have_x,lim&&i==num);//lim&&i==num，在最开始，取出的num是最高位，所以如果i比num小，那么i的下一位都可以到达9，而i==num了，最大能到达的就只有,bit[pos-1]
    }
    if(!lim)
        dp[pos][mod][have] = ans;
    return ans;
}

int main()
{
    int n,len;
    while(~scanf("%d",&n))
    {
        memset(bit,0,sizeof(bit));
        memset(dp,-1,sizeof(dp));
        len = 0;
        while(n)
        {
            bit[++len] = n%10;
            n/=10;
        }
        printf("%d\n",dfs(len,0,0,1));
    }

    return 0;
}