数位dp学习记录
This blog is a derivative of 数位dp总结 之 从入门到模板 by wust_wenhao (csdn) #51 D. Beautiful numbers （数位dp+离散化）under CC 4.0 BY-SA, example codes are modified, some contents are added
引入
数位dp是一种计数用的dp，一般就是要统计一个区间[le,ri]内满足一些条件数的个数。所谓数位dp，字面意思就是在数位上进行dp咯。数位还算是比较好听的名字，数位的含义：一个数有个位、十位、百位、千位......数的每一位就是数位啦！
之所以要引入数位的概念完全就是为了dp。数位dp的实质就是换一种暴力枚举的方式，使得新的枚举方式满足dp的性质，然后记忆化就可以了。
两种不同的枚举：对于一个求区间[le,ri]满足条件数的个数，最简单的暴力如下：
for(int i=le;i<=ri;i++)
if(right(i)) ans++;
然而这样枚举不方便记忆化，或者说根本无状态可言。
新的枚举：控制上界枚举，从最高位开始往下枚举，例如：ri=213，那么我们从百位开始枚举：百位可能的情况有0,1,2(觉得这里枚举0有问题的继续看)
然后每一位枚举都不能让枚举的这个数超过上界213（下界就是0或者1，这个次要），当百位枚举了1，那么十位枚举就是从0到9，因为百位1已经比上界2小了，后面数位枚举什么都不可能超过上界。所以问题就在于：当高位枚举刚好达到上界是，那么紧接着的一位枚举就有上界限制了。具体的这里如果百位枚举了2，那么十位的枚举情况就是0到1，如果前两位枚举了21，最后一位之是0到3(这一点正好对于代码模板里的一个变量limit 专门用来判断枚举范围)。最后一个问题：最高位枚举0：百位枚举0，相当于此时我枚举的这个数最多是两位数，如果十位继续枚举0，那么我枚举的就是以为数咯，因为我们要枚举的是小于等于ri的所以数，当然不能少了位数比ri小的咯！(这样枚举是为了无遗漏的枚举，不过可能会带来一个问题，就是前导零的问题，模板里用lead变量表示，不过这个不是每个题目都是会有影响的，可能前导零不会影响我们计数，具体要看题目)
由于这种新的枚举只控制了上界所以我们的Main函数总是这样:
int main()
{
long long le,ri;
while(~scanf("%lld%lld",&le,&ri))
printf("%lld\n",solve(ri)-solve(le-1));
}
统计[1,ri]数量和[1,le-1]，然后相减就是区间[le,ri]的数量了，这里我写的下界是1，其实0也行，反正相减后就没了，注意题目中le的范围都是大于等于1的(不然le=0,再减一就G_G了)
在讲例题之前先讲个基本的动态模板(先看后面的例题也行)：dp思想，枚举到当前位置pos，状态为state(这个就是根据题目来的，可能很多，毕竟dp千变万化)的数量(既然是计数,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判断枚举的上界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));
}
}
相信读者还对这个有不少疑问，笔者认为有必要讲一下记忆化为什么是if(!limit)才行，大致就是说有无limit会出现状态冲突，举例：
约束：数位上不能出现连续的两个1(11、112、211都是不合法的)
假设就是[1,210]这个区间的个数
状态:dp[pos][pre]:当前枚举到pos位，前面一位枚举的是pre(更加前面的位已经合法了)，的个数(我的pos从0开始)
先看错误的方法计数，就是不判limit就是直接记忆化
那么假设我们第一次枚举了百位是0，显然后面的枚举limit=false，也就是数位上0到9的枚举，然后当我十位枚举了1，此时考虑dp[0][1],就是枚举到个位，前一位是1的个数，显然dp[0][1]=9;(个位只有是1的时候是不满足的)，这个状态记录下来，继续dfs，一直到百位枚举了2，十位枚举了1，显然此时递归到了pos=0,pre=1的层，而dp[0][1]的状态已经有了即dp[pos][pre]!=-1；此时程序直接return dp[0][1]了，然而显然是错的，因为此时是有limit的个位只能枚举0，根本没有9个数，这就是状态冲突了。有lead的时候可能出现冲突，这只是两个最基本的不同的题目可能还要加限制，反正宗旨都是让dp状态唯一
对于这个错误说两点：一是limit为true的数并不多，一个个枚举不会很浪费时间，所以我们记录下! limit的状态解决了不少子问题重叠。第二，有人可能想到把dp状态改一下dp[pos][state][limit]就是分别记录不同limit下的个数，这种方法一般是对的，关于这个具体会讲，下面有题bzoj3209会用到这个。
数位的部分就是这些，然后就是难点，dp部分，dp大牛的艺术，弱鸡只能看看+...+
既然从高位往低位枚举，那么状态一般都是与前面已经枚举的数位有关并且通常是根据约束条件当前枚举的这一位能使得状态完整(比如一个状态涉及到连续k位，那么就保存前k-1的状态，当前枚举的第k个是个恰好凑成成一个完整的状态，不过像那种状态是数位的和就直接保存前缀和为状态了)，不过必然有一位最简单的一个状态dp[pos]当前枚举到了pos位。dp部分就要开始讲例题了，不过会介绍几种常用防tle的优化。
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int a[20],dp[2][20];
int dfs(int pos,int pre,int sta,bool lim){
//pos:position [0,n)
//pre:previous selected number
//sta:status, it means pre==6 in this problem
//lim:limitation, it means if the i-th numbers before pos are all a[i] or not
if(pos==-1){//the number 0
return 1;
}
if(!lim&&dp[sta][pos]!=-1){//memorization
return dp[sta][pos];
}
int rg=lim?a[pos]:9,tmp=0;
for(int i=0;i<=rg;++i){
if(pre==6&&i==2) continue;
if(i==4) continue;
tmp+=dfs(pos-1,i,i==6,lim&&i==a[pos]);
}
if(!lim) dp[sta][pos]=tmp;
return tmp;
}
int solve(int x){
int pos=0;
while(x){
a[pos++]=x%10;
x/=10;
}
return dfs(pos-1,-1,0,1);
}
int main(){
int l,r;
while(~scanf("%d%d",&l,&r)&&l+r){
memset(dp,-1,sizeof dp);
printf("%d\n",solve(r)-solve(l-1));
}
return 0;
}
入门就不多讲了，开始讲常用优化吧！
第一:memset(dp,-1,sizeof dp);放在多组数据外面。
例题：HDU 4734
#include<bits/stdc++.h>
using namespace std;
const int N=10000+5;
int dp[11][N];
int a[20],fa;
int f(int x){
int ans=0,pw=1;
while(x){
ans+=x%10*pw;
pw<<=1;
x/=10;
}
return ans;
}
int dfs(int pos,int sum,bool lim){
if(pos==-1){
return sum<=fa;
}
if(sum>fa){
return 0;
}
if(!lim&&dp[pos][fa-sum]!=-1){
return dp[pos][fa-sum];
}
int rg=lim?a[pos]:9,ans=0;
for(int i=0;i<=rg;++i){
ans+=dfs(pos-1,sum+i*(1<<pos),lim&&i==a[pos]);
}
if(!lim){
dp[pos][fa-sum]=ans;
}
return ans;
}
int solve(int x){
int pos=0;
while(x){
a[pos++]=x%10;
x/=10;
}
return dfs(pos-1,0,1);
}
int main(){
int T;
scanf("%d",&T);
memset(dp,-1,sizeof dp);
for(int i=1;i<=T;++i){
int aa,bb;
scanf("%d%d",&aa,&bb);
fa=f(aa);
printf("Case #%d: %d\n",i,solve(bb));
}
return 0;
}
#include<cstdio>
#include<cstring>
#pragma comment(linker, "/STACK:10240000,10240000")
using namespace std;
int dp[33][65];
int a[33];
int dfs(int pos,int dlt,bool lead,bool lim){
if(pos==-1){
return dlt>=32;
}
if(!lim&&!lead&&dp[pos][dlt]!=-1){
return dp[pos][dlt];
}
int rg=lim?a[pos]:1;
int ans=0;
for(int i=0;i<=rg;++i){
if(lead&&i==0){
ans+=dfs(pos-1,dlt,lead,lim&&i==a[pos]);
}
else{
ans+=dfs(pos-1,dlt+(i==0?1:-1),lead&&i==0,lim&&i==a[pos]);
}
}
if(!lim&&!lead){
dp[pos][dlt]=ans;
}
return ans;
}
int solve(int x){
int i=0;
memset(dp,-1,sizeof dp);
while(x){
a[i++]=x&1;
x>>=1;
}
return dfs(i-1,32,1,1);
}
int main(){
int a,b;
scanf("%d%d",&a,&b);
printf("%d",solve(b)-solve(a-1));
return 0;
}
Bit Sequence（2020 ICPC济南站 L）
Let denote the number of 1s in the binary representation of x.
Now MianKing has a sequence a0...m−1 and he wants to know the number of integer x∈[0,L] satisfies that: mod2=a_i∀i∈[0,m−1],f(x+i) mod 2=ai
You need to help him calculate the answer.
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=100+5;
int a[N],dig[N],cnt,m,f[550];
ll dp[65][2][2][2],L;
ll cal(int sum,int one,int lim){
int s=lim?L%128:127;
ll ans=0;
for(int i=0;i<=s;++i){
bool ff=1;
for(int j=0;j<m&&ff;++j){
if(i+j<128){
ff=(f[i+j]^sum)==a[j+1];
}else{
ff=(f[i+j]^one^sum==a[j+1]);
}
}
ans+=ff;
}
return ans;
}
ll dfs(int pos,int sum,int one,int lim){
ll &x=dp[pos][sum][one][lim];
if(x!=-1) return x;
if(pos<=6){
x=cal(sum,one,lim);
return x;
}
int rg=lim?dig[pos]:1;
ll ans=0;
for(int i=0;i<=rg;++i){
int no=one;
if(i){
no^=1;
}else{
no=0;
}
ans+=dfs(pos-1,sum^i,no,lim&&i==rg);
}
return x=ans;
}
ll solve(ll x){
memset(dp,-1,sizeof dp);
memset(dig,0,sizeof dig);
cnt=0;
int len=0;
for(int i=63;i>=0;--i){
dig[i]=(x>>i)&1;
if(dig[i]){
len=max(len,i);
}
}
return dfs(len,0,0,1);
}
int main(){
for(int i=1;i<=512;++i){
f[i]=f[i>>1]^(i&1);
}
int T;
scanf("%d",&T);
while(T--){
scanf("%d%lld",&m,&L);
for(int i=1;i<=m;++i){
scanf("%d",&a[i]);
}
printf("%lld\n",solve(L));
}
return 0;
}
hdu355 Bomb
若从反面做，先找没有49的数，和不要62基本相同。
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll dp[2][100];
ll a[100];
ll dfs(int pos,int pre,bool lim){
if(pos==-1){
return 1ll;
}
if(!lim&&dp[pre==4][pos]!=-1) return dp[pre==4][pos];
int rg=lim?a[pos]:9;
ll ans=0;
for(int i=0;i<=rg;++i){
if(pre==4&&i==9){
continue;
}
ans+=dfs(pos-1,i,lim&&i==a[pos]);
}
if(!lim){
dp[pre==4][pos]=ans;
}
return ans;
}
int main(){
int T;
scanf("%d",&T);
while(T--){
memset(dp,-1,sizeof dp);
ll len=0;
ll n;
scanf("%lld",&n);
ll tmp=n;
while(n){
a[len++]=n%10;
n/=10;
}
printf("%lld\n",tmp+1-dfs(len-1,0,1));
}
return 0;
}
从正面做
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll dp[3][100];
ll a[100];
ll dfs(int pos,int sta,bool lim){
if(pos==-1){
return sta==2;
}
if(!lim&&dp[sta][pos]!=-1) return dp[sta][pos];
int rg=lim?a[pos]:9;
ll ans=0;
for(int i=0;i<=rg;++i){
int ns=sta;
if(ns<2){
if(i==4){
ns=1;
}else if(i==9&&ns==1){
ns=2;
}else{
ns=0;
}
}
ans+=dfs(pos-1,ns,lim&&i==a[pos]);
}
if(!lim){
dp[sta][pos]=ans;
}
return ans;
}
int main(){
int T;
scanf("%d",&T);
while(T--){
memset(dp,-1,sizeof dp);
ll len=0;
ll n;
scanf("%lld",&n);
while(n){
a[len++]=n%10;
n/=10;
}
printf("%lld\n",dfs(len-1,0,1));
}
return 0;
}
hdu3652 B-number
#include<bits/stdc++.h>
using namespace std;
int dp[4][30][50],a[50];//sta==1 前方为1 sta==2 已有 13
int dfs(int pos,int sta,int m,bool lim){
if(pos==-1){
return sta==2&&m==0;
}
if(!lim&&dp[sta][m][pos]!=-1){
return dp[sta][m][pos];
}
int rg=lim?a[pos]:9,ans=0;
for(int i=0;i<=rg;++i){
int ns=sta;
if(sta==0&&i==1){
ns=1;
}
else if(sta==1){
if(i!=1)
ns=0;
if(i==3){
ns=2;
}
}
ans+=dfs(pos-1,ns,(m*10+i)%13,lim&&i==a[pos]);
}
if(!lim){
dp[sta][m][pos]=ans;
}
return ans;
}
int main(){
int n;
while(~scanf("%d",&n)){
memset(dp,-1,sizeof dp);
int len=0;
while(n){
a[len++]=n%10;
n/=10;
}
printf("%d\n",dfs(len-1,0,0,1));
}
return 0;
}
如果一个数能整除它的所有的非零数位，那么相当于它能整除个位数的最小公倍数。因此记忆化搜索中的参数除了len(当前位)和flag（是否达到上界），有一个pre_lcm表示前面的数的最小公倍数，判断这个数是否是Beautiful Numbers，还要有一个参数表示前面数，但是这个数太大，需要缩小它的范围。
可以发现所有个位数的最小公倍数是2520，假设当前的Beautiful Numbers是x，
那么 x % lcm{ dig[ i ] } = 0,
又 2520%lcm{ dig[ i ] } = 0。
那么x%2520%lcm{ dig[i] } = 0，x范围由9*10^18变为2520。
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int a[20];
ll dp[20][50][2525];
int mp[2525];
ll lcm(ll a,ll b){
return a/__gcd(a,b)*b;
}
//dp[i][j][k] 表示长度为i的，对2520取模为k的，最小公倍数序数为j的数的个数.
//1~9最小公倍数只有48个，预处理出来。（mp数组）
ll dfs(int pos,int lm,int num,bool lim){
if(pos==-1){
return num%lm==0;
}
if(!lim&&dp[pos][mp[lm]][num]!=-1){
return dp[pos][mp[lm]][num];
}
int rg=lim?a[pos]:9;
ll ans=0;
for(int i=0;i<=rg;++i){
int now=(num*10+i)%2520;
int nlm=lm;
if(i) nlm=lcm(i,lm);
ans+=dfs(pos-1,nlm,now,lim&&i==a[pos]);
}
if(!lim){
dp[pos][mp[lm]][num]=ans;
}
return ans;
}
ll solve(ll x){
int len=0;
while(x){
a[len++]=x%10;
x/=10;
}
return dfs(len-1,1,0,1);
}
int main(){
int T;
cin>>T;
int cnt=0;
for(int i=1;i<=2520;++i){
if(2520%i==0){
mp[i]=++cnt;
}
}
memset(dp,-1,sizeof dp);
while(T--){
ll a,b;
cin>>a>>b;
cout<<solve(b)-solve(a-1)<<'\n';
}
return 0;
}
