数位 DP 学习笔记

数位统计 DP 是与数字相关的一类计数问题。在这类题目中，一般给定一些限制条件，求满足限制条件的第 $K$ 小的数是多少，或者求在区间 $[L,R]$ 内有多少个满足限制条件的数。

计数问题

给定两个正整数 $a$ 和 $b$，求在 $[a,b]$ 中的所有整数中，$0 \sim 9$ 中每个数各出现了多少次。

数据范围

对于 $30\%$ 的数据，保证 $a\le b\le10^6$；

对于 $100\%$ 的数据，保证 $1\le a\le b\le 10^{12}$。

思路

设 $f[x,k]$ 表示 $k$ 在 $1 \sim x$ 中出现的次数，那么原问题就可以转化为求 $f[b,k]-f[a-1,k](0\leq k \leq9)$。

考虑当 $x=\overline{abcdefg}$ 时。假设现在要让第 $4$ 位为 $k$。那么就可以分两种情况来讨论。

1.前面三位填的数小于 $abc$，那么此时第 $4$ 位填 $k$。后面的位数怎么填都可以满足题意，那么对答案的贡献就是 $abc*10^3$。

2.前面三位填的数等于 $abc$，那么此时如果 $k =d$，那么后面三位填的数就必须小于等于 $efg$ ，对答案的贡献就是 $efg+1$（还有一个 $000$）；如果此时 $k < d$，那么后面怎么填都可以，对答案的贡献就是 $10^3$；如果 $k>d$，则对答案没有贡献。

其他位置同理。当然填第一位时不考虑第一种情况。

当然，$0$ 需要特殊考虑一下，$0$ 只能从第二位开始填起，同时在情况二时，前面填的数不能为 $0$，因为本题中不考虑前导零。

code：

#include<cstdio>
#include<vector>
using namespace std;
#define int long long
int power(int a,int b){int res=1;while(b--) res*=a;return res;}
int get(vector<int> nums,int l,int r){int res=0;for(int i=l;i>=r;i--) res=res*10+nums[i];return res;}
int count(int n,int x)
{
	vector<int> nums;
	while(n)
	{
	    nums.push_back(n%10);
	    n/=10;
	}
	n=nums.size();
	int res=0;
	for(int i=x!=0?n-1:n-2;i>=0;i--)
	{
		if(i<n-1)
		{
			res+=get(nums,n-1,i+1)*power(10,i);
			if(x==0) res-=power(10,i);
		}
		if(nums[i]==x) res+=get(nums,i-1,0)+1;
		if(nums[i]>x) res+=power(10,i);
	}
	return res;
}
signed main()
{
	int a,b;
	scanf("%lld%lld",&a,&b);
	for(int i=0;i<10;i++) printf("%lld ",count(b,i)-count(a-1,i));
	puts("");
	return 0;
}

度的数量

求给定区间 $[X,Y]$ 中满足下列条件的整数个数：这个数恰好等于 $K$ 个互不相等的 $B$ 的整数次幂之和。

例如，设 $X=15,Y=20,K=2,B=2$，则有且仅有下列三个数满足题意：

$17=2^4+2^0$

$18=2^4+2^1$

$20=2^4+2^2$

数据范围

$1 \leq X \leq Y \leq 2^{31}-1$

$1 \leq K \leq 20$

$2 \leq B \leq 10$

思路

分析一下题面，可以发现一个数 $x$ 满足题意，当且仅当 $x \in [X,Y]$，并且 $x$ 的 $B$ 进制表示是一个 $1$ 的个数为 $K$ 的 $01$ 序列。

和上一题类似，先求出 $[1,Y]$ 中满足题意的数的个数，再求出 $[1,X]$ 中满足题意的数的个数。（数位 DP 常用技巧，利用前缀和的思想，将求区间内的数转化为两个区间内数相减）

设 $f[N]$ 表示 $1 \sim N$ 中满足题意的数的个数。。

设 $N$ 在 $B$ 进制表示下的第 $i$ 位为 $a$，前面的数已经填了 $tot$ 个 $1$，当：

$a=0$，那么构造的数中这一位只能为 $0$，后面也不能随便填，因为可能最终构造的数会大于 $N$。所以要交给下一位处理；

$a=1$，如果构造的数这一位填 $0$ 时，后面怎么填剩下的 $k-tot$ 个 $1$，最终的数都不会大于 $N$；对答案的贡献也就是 $C_{i-1}^{k-tot}$；如果构造的数这一位填 $1$。那么就和第一种情况类似，交给下一位处理，同时也要 $tot++$。

$a>1$，这一位填 $0$ 和第二种情况一样，但是这一位填 $1$ 时，后面怎么填还是在 $[1,N]$ 中。对答案的贡献就是 $C_{x-1}^{k-tot-1}$。此时后面的位数也就没必要枚举了。因为枚举下一位的原因是无法保证后面怎么填都在范围内。此时已经保证了，就不需要枚举了。

$a>1$
通过上面这种关系可以发现，所有的情况构成一棵树，如下图所示。

最终的答案就是所有叶子节点的方案相加。

code：

#include<cstdio>
#include<vector>
using namespace std;
const int N=35;//二进制最多有32位 
int x,y,k,b,f[N][N];
void init()
{
	for(int i=0;i<N;i++)
	    for(int j=0;j<=i;j++)
	        if(!j) f[i][j]=1;else f[i][j]=f[i-1][j-1]+f[i-1][j];
}
int query(int n)
{
	int res=0,tot=0;
	vector<int> nums;
	nums.clear();
	while(n){nums.push_back(n%b),n/=b;}
	for(int i=nums.size()-1;i>=0;i--)
	{
		if(nums[i])
		{
			res+=f[i][k-tot];
			if(nums[i]>1)
			{
				res+=f[i][k-tot-1];
				break;
			}
			tot++;
			if(tot>k) break;
		}
		if(!i&&tot==k) res++;//考虑深度最深的右叶子节点
	}
	return res;
}
int main()
{
	init();
	scanf("%d%d%d%d",&x,&y,&k,&b);
	printf("%d\n",query(y)-query(x-1));
	return 0;
}

数字游戏

定义一个数字为不下降数，当且仅当这个数从左到右各位数字呈非下降关系，如 $123$，$446$。

给定一个整数闭区间 $[a,b]$，求这个区间内有多少个不降数。

数据范围

$1 \leq a \leq b \leq 2^{31}-1$

思路

还是将问题转化为区间差。

设 $h[N]$ 表示 $1 \sim N$ 中的不下降数的个数。分类讨论，画出树状关系图。

显然，当第 $i$ 位填的数小于 $a_i$ 时，后面的数只要满足非严格单调递增即可。考虑预处理出这些方案数

设 $f[i][j]$ 表示数位为 $i$，且最高位为 $j$ 的不下降数的个数。易得状态转移方程：

$f[i][j]=\sum_{k=j}^{9}f[i-1][k]$。

最后，别忘了特判 $N$ 本身是否是一个非下降数。

code：

#include<cstdio>
#include<vector>
using namespace std;
const int N=15;
int a,b,f[N][N];
void init()
{
	for(int i=0;i<=9;i++) f[1][i]=1;
	for(int i=2;i<=10;i++)
	    for(int j=0;j<=9;j++)//可以优化，但没必要 
		    for(int k=j;k<=9;k++)
			    f[i][j]+=f[i-1][k];  
}
int query(int n)
{
	if(!n) return 1;//注意特判0 
	vector<int>nums;
	nums.clear();
	while(n) nums.push_back(n%10),n/=10;
	int res=0; 
	nums.push_back(0);
	for(int i=nums.size()-2;i>=0;i--)
	{
	    
		for(int j=nums[i+1];j<nums[i];j++) res+=f[i+1][j];
		if(i&&nums[i]>nums[i-1]) break; 
		if(!i) res++;//特判自身 
	}
	return res;
}
int main()
{
	init();
	while(scanf("%d%d",&a,&b)!=EOF) printf("%d\n",query(b)-query(a-1));
	return 0;
}

[SCOI2009] windy 数

不含前导零且相邻两个数字之差至少为 $2$ 的正整数被称为 windy 数。求 $[a,b]$ 中 windy 数的数量。

数据范围

$1 \leq a \leq b \leq 2 \times 10^9$。

思路

和上一道题类似。需要预处理出一个数组。

设 $f[i][j]$ 表示一共有 $i$ 位，最高位为 $j$ 的 windy 数的个数。得到转移方程：

$f[i][j]=\sum_{0}^{j-2}f[i-1][k]+\sum_{j+2}^{9}f[i-1][k]$。

但是需要注意，上一道题填 $\overline{0000}$ 前导零对后面的数是没有影响，但是本题就不一样了，因为如果和上一题枚举方式相同，那么形如 $\overline{03574}$ 这样的数字就不会被计算为 windy 数，所以需要特判一下位数小于 $N$ 的数，由于最高位填的是 $0$，后面怎么填都不会超过 $N$。直接统计 $\sum_{i=1}^{|n|-1}\sum_{j=1}^{9}f[i][j]$ 即可。

code：

#include<cstdio>
#include<vector>
using namespace std;
const int N=15;
int f[N][N],a,b;
int abs(int a){return a>0?a:-a;}
void init()
{
	for(int i=0;i<=9;i++) f[1][i]=1;//用到f[1][0] 时前面肯定不会是0
	for(int i=2;i<=10;i++)
	    for(int j=0;j<=9;j++)
		    for(int k=0;k<=9;k++)
			    if(abs(j-k)>=2) f[i][j]+=f[i-1][k]; 
}
int query(int n)
{
	int res=0;
	vector<int>nums;
	nums.clear();
	while(n) nums.push_back(n%10),n/=10;
	nums.push_back(-1);//因为最高位不能是0
	for(int i=nums.size()-2;i>=0;i--)
	{
		for(int j=0;j<nums[i];j++)
		    if(abs(j-nums[i+1])>=2) res+=f[i+1][j];
		if(abs(nums[i]-nums[i+1])<2) break;
		if(!i) res++;
	} 
	for(int i=1;i<nums.size()-1;i++)
	    for(int j=1;j<=9;j++) res+=f[i][j];
	return res;
}
int main()
{
	init();
	scanf("%d%d",&a,&b);
	printf("%d\n",query(b)-query(a-1));
	return 0;
}

数字游戏 II

定义一个数为取模数，当且仅当这个数字各位上之和 $\bmod N=0$。

给定 $a,b$,求在 $[a,b]$ 内的取模数个数。

数据范围

$1 \leq a,b \leq 2^{31}-1$,

$1 \leq N <100$

思路

设 $f[i][j][k]$ 表示一共有 $i$ 位，最高位为 $j$，各位上的数字之和模 $N$ 为 $k$ 的数字的个数。得到状态转移方程：

$f[i][j][k]=\sum_{t=0}^{9}f[i-1][t][(k-j)\% P]$。

假设前面位填的数字之和是 $sum$，当前位填的是 $x$，后面几位需要填的数字之和为 $res$。

就有 $(sum+x+res) \bmod N=0$，移项得 $(res+x) \equiv -(sum) (\bmod N)$。

对答案的贡献就是 $f[i][j][-(sum)\% N]$。

code：

#include<cstdio>
#include<vector>
#include<cstring>
using namespace std;
const int N=15;
const int M=110;
int f[N][N][M],P;
int mod(int a,int b){ return (a%b+b)%b;}//处理负数
void init()
{
    memset(f,0,sizeof(f));//多测不清空，爆零两行泪
	for(int i=0;i<=9;i++) f[1][i][i%P]=1;
	for(int i=2;i<=10;i++)
	    for(int j=0;j<=9;j++)
	        for(int k=0;k<P;k++)
	            for(int t=0;t<=9;t++)
	                f[i][j][k]+=f[i-1][t][mod(k-j,P)];
}
int query(int n)
{
	if(!n) return 1;
	int res=0;
	vector<int>nums;
	nums.clear();
	while(n) nums.push_back(n%10),n/=10;
	int sum=0;
	for(int i=nums.size()-1;i>=0;i--)
	{
		for(int j=0;j<nums[i];j++) 
		    res+=f[i+1][j][mod(-sum,P)];
		sum+=nums[i];
		if(!i&&sum%P==0) res++; 
	}
	return res;
}
int main()
{
	int a,b;
	while(scanf("%d%d%d",&a,&b,&P)!=EOF)
	{
		init();//模数不同，所以需要多次预处理
		printf("%d\n",query(b)-query(a-1)); 
	}
	return 0;
}

不要62

不吉利的数字为所有含有 $4$ 或 $62$ 的号码。例如：$62315,73418,88914$ 都属于不吉利号码。但是，$61152$ 虽然含有 $6$ 和 $2$，但不是连号，所以不属于不吉利数字之列。

给出 $n,m$，求在 $[n,m]$ 不含有不吉利的数的个数。

数据范围

$1 \leq n \leq m \leq 10^9$

思路

定义 $f[i][j]$ 表示位数为 $i$，最高位为 $j$ 的不含有不吉利的数的的个数。得到状态转移方程：

$f[i][j]=\sum_{k=0}^{9} f[i-1][k](j \ne 4,k \ne 4,j*10+k\ne62)$。

其他的步骤就和上面差不多了。。。所以其实数位 DP 的套路基本上都一样。

code：

#include<vector>
#include<cstdio>
using namespace std;
const int N=15;
int f[N][N],a,b;
void init()
{
	for(int i=0;i<=9;i++)
	    if(i!=4) f[1][i]=1;
	for(int i=1;i<=10;i++)
	    for(int j=0;j<=9;j++)
	    {
	    	if(j==4) continue;
	    	for(int k=0;k<=9;k++)
	    	{
	    		if(k==4||j*10+k==62) continue;
	    		f[i][j]+=f[i-1][k];
			}
		}
}
int query(int n)
{
	if(!n) return 1;
	vector<int> nums;
	nums.clear();
	while(n) nums.push_back(n%10),n/=10;
	nums.push_back(114514);//不影响最高位 
	int res=0;
	for(int i=nums.size()-2;i>=0;i--)
	{
		for(int j=0;j<nums[i];j++)
	    {
	    	if(j==4||nums[i+1]*10+j==62) continue;
	    	res+=f[i+1][j];
		}
		if(nums[i+1]*10+nums[i]==62||nums[i]==4) break;
		if(!i) res++;
	}
	return res;
}
int main()
{
	init();
	while(scanf("%d%d",&a,&b),a||b) printf("%d\n",query(b)-query(a-1));
	return 0;
}

恨7不成妻

如果一个整数符合下面三个条件之一，那么我们就说这个整数和 $7$ 有关：

1.整数中某一位是 $7$；

2.整数的每一位加起来的和是 $7$ 的整数倍；

3.这个整数是 $7$ 的整数倍。

求一个区间内和 $7$ 无关的整数的平方和。

数据范围

$1 \leq T \leq 50$,

$1 \leq L \leq R \leq 10^{18}$

思路

本题的限制条件特别多，对于第一个条件显然很容易限制，而对于后面两个条件，就有一些繁琐了。

设 $f[i][j][a][b]$ 表示位数为 $i$，最高位的数为 $j$，这个数本身对 $7$ 取模等于 $a$。这个数各个数位上之和对 $7$ 取模等于 $b$ 的所有数的平方和。

那么所有可以转移的状态就是 $f[i-1][k][(a-j*10^{i-1})\%7][(b-j)\%7]$。

设这些转移的数分别为 $A_1,A_2,\dots,A_t$。

那么转移就是 $f[i][j][a][b]=\sum_{k=1}^{t}(j*10^{i-1}+A_k)^2$。

展开，得到 $(j*10^{i-1})^2*t+2*j*10^{i-1}*\sum_{k=1}^{t}A_k+\sum_{k=1}^{t}A_k^2$。

同理，一次方和为：

$\sum_{k=1}^{t}(j*10^{i-1}+A_k)=t*j*10^{i-1}+\sum_{k=1}^{t}A_k$。

所以，如果把 $t$ 看成 $A_k$ 的 $0$ 次方之和，$f$ 中需要记录的就是 $A_k$ 的 $0,1,2$ 次方。

然后就到了激动人心的填数环节。

设当前填的是第 $i$ 位，前面填的数是 $last_a=\overline{xyz}$，前面填的各个数位之和是 $last_b=x+y+z$。那么当前位 $j$ 和前面的 $a$ 以及 $b$ 就需要满足：

1.$(last_a*10^{i}+j*10^{i-1}+a)\bmod 7 \ne0$。

2.$(last_b+j+b)\bmod 7\ne 0$。

对两个式子移项，得到：

1.$(j*10^{i-1}+a) \mod 7\ne -(last_a*10^i)\bmod 7$。

2.$(j+b)\bmod 7\ne -(last_b) \bmod 7$。

最后就可以愉快地写代码了。

#include<cstdio>
#include<vector>
using namespace std;
#define int long long
const int N=25;
const int p=1e9+7;
struct node{
	int s0,s1,s2;
}f[N][10][7][7];
int l,r;
int p7[N],p9[N];//10^i 对7取模，对1e9+7取模 
int mod(int a,int b){return (a%b+b)%b;}//处理负数取模 
void init()
{
	p7[0]=p9[0]=1;
	for(int i=1;i<N;i++) p7[i]=p7[i-1]*10%7,p9[i]=p9[i-1]*10ll%p;
	for(int i=0;i<=9;i++)
	{
		if(i==7) continue;
		f[1][i][i%7][i%7].s0++;f[1][i][i%7][i%7].s1+=i;f[1][i][i%7][i%7].s2+=i*i;
	}
	for(int i=2;i<N;i++)
	    for(int j=0;j<=9;j++)
	    {
	    	if(j==7) continue;
	    	for(int a=0;a<7;a++)
	            for(int b=0;b<7;b++)
	            {
	                for(int k=0;k<=9;k++)
	                {
	                	if(k==7) continue;
	                	node &v1=f[i][j][a][b],&v2=f[i-1][k][mod(a-j*p7[i-1],7ll)][mod(b-j,7ll)];
	                	v1.s0=(v1.s0+v2.s0)%p;
	                	v1.s1=(v1.s1+p9[i-1]*v2.s0%p*j%p+v2.s1)%p;
	                	v1.s2=(v1.s2+j*p9[i-1]%p*j%p*p9[i-1]%p*v2.s0%p+2ll*j*p9[i-1]%p*v2.s1%p+v2.s2)%p;
					}
	            }
	                
		}
	        
}
node get(int i,int j,int a,int b)//注意这里是不等于a,b 
{
	node tmp;
	tmp.s0=tmp.s1=tmp.s2=0;
		for(int x=0;x<7;x++)
		{
			if(x==a) continue;
			for(int y=0;y<7;y++)
			{
				if(y==b) continue;
				tmp.s0=(tmp.s0+f[i][j][x][y].s0)%p;
				tmp.s1=(tmp.s1+f[i][j][x][y].s1)%p;
				tmp.s2=(tmp.s2+f[i][j][x][y].s2)%p;
			}
		}
	return tmp;
}
int query(int n)
{
	if(!n) return 0;
	vector<int> nums;
	nums.clear();
	while(n) nums.push_back(n%10),n/=10;
	int last_a=0,last_b=0,res=0;
	for(int i=nums.size()-1;i>=0;i--)
	{
		for(int j=0;j<nums[i];j++)
		{
		    if(j==7) continue;
			int a=mod(-last_a*p7[i+1],7ll);
			int b=mod(-last_b,7ll);
			node v=get(i+1,j,a,b);
			res=(res+(last_a%p)*(last_a%p)%p*p9[i+1]%p*p9[i+1]%p*v.s0%p+last_a%p*v.s1%p*p9[i+1]%p*2ll%p+v.s2)%p;//注意相乘顺序，不然很容易溢出
		}
		if(nums[i]==7) break;
		last_a=last_a*10ll+nums[i];
		last_b+=nums[i];
		if(!i&&last_a%7&&last_b%7)
		{
			last_a%=p;
			res=(res+last_a*last_a%p)%p;
		}
	}
	return res;
}
signed main()
{
	init();
	int T;scanf("%lld",&T);
	while(T--) scanf("%lld%lld",&l,&r),printf("%lld\n",mod(query(r)-query(l-1),p));
	return 0;
}