[一本通提高数位动态规划]恨7不成妻--题解--胎教级教学

1前言

一本通提高篇的毒瘤数位dp终于要结束了
然而…我遇到了这道毒中之毒
网上的题解都是依托构思，我猜他们都是抄的代码
我要是抄代码用你发？
甚至有人直接抄袭acwing yxc老师的图片
几十篇题解凑不出完整的思路，你家题解是散装的
所有人都在劝你抄代码，只有我在写胎教级教学
本文的所有思路均有证明，终结你关于这道毒瘤题的一切疑问
所有公式均使用$Latex$，包清晰
本题的难度较高，新手不要轻易尝试
建议先阅读
论数位dp–胎教级教学
B3883 [信息与未来 2015] 求回文数 数位dp题解
论进制类型的数位dp:胎教级教学
[一本通提高数位动态规划]数字游戏：取模数题解

2问题

如图

注意！要求的是平方和，这是本题最大的毒瘤点
（出题人yyds （永远单身） ）
而且，先放下平方和不看，本题对于合法数的约束条件有整整$3$个
面对复杂的问题，我们可以使用dp式解题法
先求解子问题，再转移
我们一步一步地解决吧

3化繁为简–对于方案数的求解

（1）子问题的分解

我们发现，求解平方和的性质是如此毒瘤，以至于扰乱了整个dp过程
一步到正解过于困难，我们可以抛开这个条件，先考虑求解合法方案数

（2）数位dp-part1状态设置–利用约束条件推状态

dp的状态设置要满足两个条件
1.构成子问题，即和最终要求解的问题有一致性
2.可转移性，可以利用已经求出的状态来推新的状态
首先，对于子问题，我们转化原问题的约束条件
设一个合法方案的数值为$x$，$x$的第$i$位为$x_i$，则有
$$\{\begin{array}{c}\forall x_i，x_i\ne 7\\ \sum x_{i}mod7\ne 0\\ xmod7\ne 0\end{array}$$
这三个条件互相不干扰，我们为$dp$数组增加三个维度
1.$x$的最高位
2.$\sum x_{i}mod7$的值
3.$xmod7$的值
然后，考虑可转移性
可以发现，我们在$x$前面插入一位数$k$，设$k$为第$i$位数，新的状态可以由之前的转移过来，（因为状态合法和不合法都要处理，为了体现可转移性，我们假定当前状态是合法的）
对于维度1，直接枚举可能的最高位（当然不能为$7$）
对于维度2，取$(7-k)mod7$（温馨提示：在合法的情况下为$7-k$，因为各位和模$7$为$0$）
对于维度3，取$(7-k\times 10^i)$
这种转移方式可以采用，但是因为要枚举当前位数$-1$的情况
我们还要再开一维，为当前的位数
所以状态得出
$d{p}_{i,j,k,l}$为$i$位，$j$开头，数值模$7$为$k$，各为之和模$7$为$l$的方案个数

（3）数位dp-part2状态转移

其实状态转移的方法，我们已经在设置状态的时候考虑好了
枚举$i,j,k,l$，即$dp$的所有维度，此外，还需枚举一个$h$，代表前一位的情况
得状态转移方程：（这里有点绕，慢慢理解即可）
$d{p}_{i,j,k,l}=d{p}_{i,j,k,l}+d{p}_{i-1,h,mod(k-(10^i\times j)),mod(l-j)}$
其中$mod(x)$代表数$x$模$7$取正数
逆天状态转移方程
我们再来一遍，一维一维看
维度$i$：上一位当然为$i-1$
维度$j$：枚举的$h$
维度$k$：$j$所在第$i$位，值增加了$j\times 10^i$变成$k$，得这一维为$mod(k-(10^i\times j))$
维度$l$：加上一位$j$，各位之和变为$l$ ，得$mod(l-j)$
（觉得状态转移方程太复杂不可读，拆开看好一些QwQ）
看到这了，就该代码出场了
附初始化部分的代码（c++）

const long long MOD = 1e9+7; 
long long dp[20][20][10][10];//状态 
long long e[20];//预处理10的幂 
long long mmod(long long x){//模7防负数 
	return(x%7+7)%7;
}
long long n,a,b;
void init(){
	e[0] = 1;//10^0
	for(long long i = 0;i<=9;i++){//预处理个位数 
		dp[1][i][i%7][i%7] = 1-(i==7);
	}
	for(long long i = 1;i<=20;i++){
		e[i] = e[i-1]*10;
		e[i]%=7;
		for(long long j = 0;j<=9;j++){
			if(j==7){//判断7 
				continue;
			}
			for(long long k = 0;k<7;k++){
				for(long long l = 0;l<7;l++){
					for(long long h = 0;h<=9;h++){
						if(h!=7){//判断7 
							dp[i][j][k][l]+=dp[i-1][h][mmod(k-(j*e[i]))][mmod(l-j)];//状态转移方程的体现 
							dp[i][j][k][l]%=MOD;
						}
					}
				}
			}
		}
	}
}

（4）数位dp-part3利用状态求解问题

我们依旧先划分问题，举例数$23456$
可划分为$1-19999$和$20000-23456$
首先考虑$1-19999$区间，对于$i$位（此处$i=5$），枚举$0\le j\le 9，j\ne 7$
答案加上$d{p}_{i,j,k,l}$即可，这里$k,l$都是合法的
那怎么判断合法呢，分别处理前面的数值和各位和，就可以用来判断了
我们在写代码时可以用函数将这一步独立出来
至于$20000-23456$这个区间，向后递推处理即可，边界问题要特判，其他就没什么难的了

（5）方案数求解的代码

代码如下，记得模上$10^9+7$，记得开$longlong$
（作者因为没调用初始化函数调了半天）

#include<bits/stdc++.h>
using namespace std;
const long long MOD = 1e9+7; 
long long dp[30][20][10][10];//状态 
long long e[20];//预处理10的幂 
long long mmod(long long x){//模7防负数 
	return(x%7+7)%7;
}
long long n,a,b;
void init(){
	e[0] = 1;//10^0
	for(long long i = 0;i<=9;i++){//预处理个位数 
		dp[1][i][i%7][i%7] = 1-(i==7);
	}
	for(long long i = 1;i<=20;i++){
		e[i] = e[i-1]*10;
		e[i]%=7;
		for(long long j = 0;j<=9;j++){
			if(j==7){//判断7 
				continue;
			}
			for(long long k = 0;k<7;k++){
				for(long long l = 0;l<7;l++){
					for(long long h = 0;h<=9;h++){
						if(h!=7){//判断7 
							dp[i][j][k][l]+=dp[i-1][h][mmod(k-(j*e[i]))][mmod(l-j)];//状态转移方程的体现 
							dp[i][j][k][l]%=MOD;
						}
					}
				}
			}
		}
	}
}
long long get(long long i1,long long j1,long long k1,long long l1){
	long long ans = 0;
	for(int k = 0;k<7;k++){
		for(int l = 0;l<7;l++){
			if(k!=k1&&l!=l1){
				ans+=dp[i1][j1][k][l];
			}
		}
	}
	return ans;
}
long long solve(long long x){
	if(x==0){
		return 0;
	}
	long long h = x,s[1145],idx = 0,ans = 0,tmp1 = 0,tmp2 = 0;
	while(h){
		s[++idx] = h%10;
		h/=10; 
	}
	for(int i = idx;i>=1;i--){
		for(int j = 0;j<s[i];j++){
			if(j==7){
				continue;
			}
			long long k1 = mmod(-tmp1*e[i]),l1 = mmod(-tmp2);
			ans+=get(i,j,k1,l1);
		}
		if(s[i]==7){
			break;
		}
		tmp1 = tmp1*10+s[i];
		tmp2 = tmp2+s[i];
		if(i==1&&tmp1%7!=0&&tmp2%7!=0){
			ans++;
		}
	}
	return ans;
} 
int main(){
	init();
	cin>>n;
	while(n--){
		cin>>a>>b;
		long long ans = solve(b)-solve(a-1);
		cout<<ans<<endl;
	}
	return 0;
}

4问题转化–平方和的加入

（1）状态转移–问题的变化

我们的dp式解题法已经求好了状态，接下来该进行转移了
平方和…这个问题会破坏掉我们的整个求解过程
所以我们要尝试在原来求解方式的基础上改进，就要利用好平方和的性质

（2）改进算法–从状态出发

首先，要具有子问题的性质，我们不可能处理出所有符合条件的数，再开一个数组麻烦，那就开一个结构体
使原有的$dp$数组不止存方案数，还存储所有合法数的平方和
对于$d{p}_{i,j,k,l}$，在$i=1$的条件下显然可以直接求出平方和（就一种方案）
还记得我们求方案数时状态转移的原理吗
在原有的数前面加上一位，那么我们设原数为$x$，新的一位为$h$
则新的数为$h\times 10^i+x$，表示为平方$(h\times 10^i+x{)}^2$
根据完全平方公式得原式等价于
$(h\times 10^i{)}^2+2\times (h\times 10^i)\times x+x^2$
进一步化简：
$h^2\times 10^{2i}+2\times 10^{i}hx+x^2$
我们发现了一个极好的性质！！！，$x^2$，这正是子问题
对于每一个新的数，我们都套用公式
设原来$n$个$x$的平方和为$su{m}_x$，新数$y$的平方和为$su{m}_y$，则有
$su{m}_y=n\times h^2\times 10^{2i}+2\times 10^{i}h(x_1+x_2......+x_n)+su{m}_x$
原来的方案数和平方和都用上了，好啊，$10$的幂照常预处理
但是呢，意外出现了，$x$的求和我们没存过
那还想啥了，存呗
想想转移（以下所有设的未知数的意思和上文相同）
每个新数$y=h\times 10^i+x$
则$\sum y=\sum x+n\times h\times 10^i$
归纳以上内容，得状态转移方程（枚举的上一位依旧设为$h$）
（此处为了清晰不用$dp$的结构体表示形式，$cnt$代指方案数，$sum$代指求和，$res$代指平方和，如果觉得太复杂不可读也可以先看看后面的代码部分）
（为了更加清晰可读，前一个状态的$k,l$，即$mod(k-(10^i\times j)),mod(l-j)$统一替换为$u,v$）
（所有上一个状态的下标都统一表示为$s2$，当前状态表示为$s1$）
（公式不代表代码，取模部分这里不体现代码里会有的）
$cn{t}_{s1}=cn{t}_{s1}+cn{t}_{s2}$
$su{m}_{s1}=su{m}_{s1}+su{m}_{s2}+cn{t}_{s2}\times j\times 10^i$
$re{s}_{s1}=re{s}_{s1}+cn{t}_{s2}\times j^2\times 10^{2i}+2\times 10^{i}jx\times su{m}_{s2}+re{s}_{s2}$
初始化这边的代码也一并附上，注意循环最里层的写法，直接利用指针把原$dp$数组的值带入到$x$里，多使用这些技巧可以改善码风
附初始化代码（c++）

const long long MOD = 1e9+7; 
long long e[20],g[20];//预处理10的幂
struct node{
	long long cnt,sum,res;
}dp[30][20][10][10];//状态 
long long mmod(long long x){//模7防负数 
	return (x%7+7)%7;
}
long long mmmod(long long x){//模1e9+7防负数
	return (x%MOD+MOD)%MOD;
}
long long n,a,b;
void init(){
	e[0] = 1;//10^0
	g[0] = 1;
	for(long long i = 0;i<=9;i++){//预处理个位数 
		if(i==7){
			continue;
		}
		node &u = dp[1][i][i%7][i%7];
		u.cnt++;
		u.sum+=i;
		u.res+=i*i;
	}
	for(long long i = 1;i<=20;i++){
		e[i] = e[i-1]*10;
		e[i]%=7;
		g[i] = g[i-1]*10;
		g[i]%=MOD;
		for(long long j = 0;j<=9;j++){
			if(j==7){//判断7 
				continue;
			}
			for(long long k = 0;k<7;k++){
				for(long long l = 0;l<7;l++){
					for(long long h = 0;h<=9;h++){
						if(h!=7){//判断7 
							node &v = dp[i][j][k][l],u = dp[i-1][h][mmod(k-j*e[i])][mmod(l-j)];
							v.cnt = mmmod(v.cnt+u.cnt);
							v.sum = mmmod(v.sum+1ll*j%MOD*(e[i]%MOD)%MOD*u.cnt%MOD+u.sum);
							v.res = mmmod(v.res+1ll*j%MOD*u.cnt%MOD*(e[i]%MOD)%MOD*j%MOD*(e[i]%MOD)%MOD+1ll*u.sum%MOD*2%MOD*j%MOD*(e[i]%MOD)%MOD+u.sum);
						}
					}
				}
			}
		}
	}
}

（3）利用新状态–问题再求解

问题的划分和上文相同，这里便不再赘述
上文程序中的$get$函数无需大改，只是需要返回结构体变量
需要改的是$solve$函数
我们原来使用的将答案累加到$ans$变量上的方式可以继续沿用
为什么?因为将平方和加到一个现有的平方和的结果上，无需现有平方和结果对应的方案数和数的求和，$ans$还可以是$longlong$型的
说人话就是求$res$用不着$cnt,sum$管，不用开结构体变量
至于累加平方和的公式又要再打一遍
这就是本题的毒瘤之处
其实那些公式推出来了，剩下的步骤思路难度不高，有的只是对手的折磨

（4）问题的终结–附上代码

话不多说，直接给代码（c++）

#include<bits/stdc++.h>
using namespace std;
const long long MOD = 1e9+7; 
long long e[30],g[30];//预处理10的幂
struct node{
	long long cnt,sum,res;
}dp[40][30][20][20];//状态 
long long mmod(long long x){//模7防负数 
	return (x%7+7)%7;
}
long long mmmod(long long x){//模1e9+7防负数
	return (x%MOD+MOD)%MOD;
}
long long n,a,b;
void init(){
	e[0] = g[0] = 1;//10^0
	e[1] = g[1] = 10;
	for(long long i = 0;i<=9;i++){//预处理个位数 
		if(i==7){
			continue;
		}
		node &u = dp[1][i][i%7][i%7];
		u.cnt++;
		u.sum+=i;
		u.res+=i*i;
	}
	long long pow = 10;
	for(long long i = 2;i<20;i++,pow*=10){
		e[i] = e[i-1]*10;
		e[i]%=7;
		g[i] = g[i-1]*10;
		g[i]%=MOD;
		for(long long j = 0;j<=9;j++){
			if(j==7){//判断7 
				continue;
			}
			for(long long k = 0;k<7;k++){
				for(long long l = 0;l<7;l++){
					for(long long h = 0;h<=9;h++){
						if(h!=7){//判断7 
							node &v = dp[i][j][k][l],u = dp[i-1][h][mmod(k-j*pow)][mmod(l-j)];
							v.cnt = mmmod(v.cnt+u.cnt);
							v.sum = mmmod(v.sum+1ll*j%MOD*(pow%MOD)%MOD*u.cnt%MOD+u.sum);
							v.res = mmmod(v.res+1ll*j%MOD*u.cnt%MOD*(pow%MOD)%MOD*j%MOD*(pow%MOD)%MOD+1ll*u.sum%MOD*2%MOD*j%MOD*(pow%MOD)%MOD+u.res);
						}
					}
				}
			}
		}
	}
}
node get(long long i1,long long j1,long long k1,long long l1){
	long long ans1 = 0,ans2 = 0,ans3 = 0;
	for(int k = 0;k<7;k++){
		for(int l = 0;l<7;l++){
			if(k!=k1&&l!=l1){
				node st = dp[i1][j1][k][l];
				ans1=mmmod(ans1+st.cnt);
				ans2=mmmod(ans2+st.sum);
				ans3=mmmod(ans3+st.res);
			}
		}
	}
	return {ans1,ans2,ans3};
}
long long solve(long long x){
	if(x==0){
		return 0;
	}
	long long ggg = x%MOD;
	long long h = x,s[1145],idx = 0,ans = 0,tmp1 = 0,tmp2 = 0;
	while(h){
		s[++idx] = h%10;
		h/=10; 
	}
	for(int i = idx;i>=1;i--){
		for(int j = 0;j<s[i];j++){
			if(j==7){
				continue;
			}
			long long k = mmod(-tmp1*e[i]),h = mmod(-tmp2);
			node st = get(i,j,k,h);
			ans = mmmod(ans+1ll*(tmp1%MOD)*(tmp1%MOD)%MOD*(g[i]%MOD)%MOD*(g[i]%MOD)%MOD*st.cnt%MOD+1ll*2*tmp1%MOD*(g[i]%MOD)%MOD*st.sum%MOD+st.res%MOD);
			
		}
		if(s[i]==7){
			break;
		}
		tmp1 = tmp1*10+s[i];
		tmp2+=s[i];
		if(i==1&&tmp1%7&&tmp2%7){
			ans = mmmod(ans+ggg*ggg%MOD);
		}
	}
	return ans;
} 
signed main(){
	init();
	cin>>n;
	while(n--){
		cin>>a>>b;
		long long ans = mmmod(solve(b)-solve(a-1));
		cout<<ans<<endl;
	}
	return 0;
}

5后记

我们就这样切掉了这道毒瘤题，作者认为这一题的难度完全可以评黑（下位黑或上位紫）
作者从早上$10$点调到晚上$8$点，终于AC，并完成了这篇博客
我觉得这一切都是值得的，我敢说我的博客比CSDN平台上的任何一篇都要详细
我可以写出更详细的题解，这就是OI事业的发展
可能某一天，我的题解也会成为"屎"一样的存在，那就证明OI的事业发展的更好了
关注CSDN@森林古猿1，我会为大家带来更多胎教级教学
本文作者是蒟蒻，如有错误请各位神犇指点
森林古猿出品，必属精品，请认准CSDN森林古猿1