数位DP复习 - Jack404

数位DP复习

数位DP

技巧：某个区间内满足某个性质的数的个数

1: \([X, Y] \rightarrow F(Y)-F(X-1)\)

2:从树的角度来考虑

例题

度的数量

题目🔗

根据题目中的条件，转化一下条件，就是求区间中的数\(x\)，满足\(x\)在\(B\)进制下有\(K\)个位上是\(1\).

我们考虑技巧1，即求出函数\(F(X)\)（区间\([0, X]\)满足条件的数的数量）。

假设一个数为

\[a_na_{n-1}\dots a_{1}a_{0} \]

我们以一颗树来考虑，先确定第\(n\)位的数，然后向下扩展

复杂度\(O(logN)\)

#include <bits/stdc++.h>

using i64 = long long;

const int N = 31;

int K, B;

int 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 dp(int n) {
	if (!n) return 0;

	std::vector<int> nums;

	while (n) nums.push_back(n % B), n /= B;

	int res = 0;
	int last = 0;

	for (int i = (int) nums.size() - 1; i >= 0; i --) {
		int x = nums[i];
		if (x) { // 求左边分支的个数
			res += f[i][K - last];
			if (x > 1) {
				if (K - last - 1 >= 0)
					res += f[i][K - last - 1];
				break;
			} else {
				last ++;
				if (last > K) break;
			}
		}
		if (!i && last == K) res ++; // 考虑最后一位是否为0
	}
	std::cout << last << "\n";
	return res;
}

int main() {
	init();

	int l, r;

	std::cin >> l >> r >> K >> B;


	std::cout << dp(r) - dp(l - 1);
}

数字游戏

题目🔗

先预处理\(dp[i][j]\)（考虑前\(i\)个数，最高位为\(j\)时的方案数量），在按树的思维进行求解。

#include <bits/stdc++.h>

using i64 = long long;

int f[40][12];

void init() {
	for (int i = 0; i <= 9; i ++) f[1][i] = 1;

	for (int i = 2; i <= 32; i ++) {
		for (int j = 0; j <= 9; j ++) {
			for (int k = j; k <= 9; k ++) {
				f[i][j] += f[i - 1][k];	
			}
		}	
	}
}

int dp(int n) {
	if (!n) return 1;

	std::vector<int> nums;

	while (n) nums.push_back(n % 10), n /= 10;

	int res = 0;
	int last = 0;

	for (int i = (int) nums.size() - 1; i >= 0; i --) {
		int x = nums[i];

		for (int j = last; j < x; j ++) {
			res += f[i + 1][j];
		}

		if (last <= x) last = x;
		else break;

		if (!i) res ++;
	}

	// for (int i = 1; i < nums.size(); i ++) {
	// 	for (int j = 1; j <= 9; j ++) {
	// 		res += f[i][j];
	// 	}	
	// }

	return res;
}

int main() {
	init();

	int l, r;

	while (std::cin >> l >> r) {
		std::cout << dp(r) - dp(l - 1) << "\n";	
	}
}

Windy数

题目🔗

由于前后两个数字只差要求小于等于\(2\)，所以我们这里先不考虑\(0\)的情况，即只考虑位数为\(n\)的情况，后续根据\(dp\)值求位数小于\(n\)的情况。

#include <bits/stdc++.h>

using i64 = long long;

int f[20][20];

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 = 0; k <= 9; k ++) {
				if (std::abs(j - k) >= 2)
					f[i][j] += f[i - 1][k];
			}
		}
	}
}

int dp(int n) {
	if (!n) return 0;	

	std::vector<int> nums;

	while (n) nums.push_back(n % 10), n /= 10;

	int res = 0;
	int last = -2;

	for (int i = (int) nums.size() - 1; i >= 0; i --) {
		int x = nums[i];

		for (int j = (i == (int) nums.size() - 1); j < x; j ++) {
			if (std::abs(j - last) >= 2)
				res += f[i + 1][j];
		}

		if (std::abs(last - x) >= 2) last = x;
		else break;

		if (!i) res ++;
	}

	// 特殊处理小于n位数的windy数
	for (int i = 1; i < nums.size(); i ++) {
		for (int j = 1; j <= 9; j ++) {
			res += f[i][j];	
		}
	}

	return res;
}

int main() {
    init();
	int l, r;

	std::cin >> l >> r;
	std::cout << dp(r) - dp(l - 1) << "\n";
}

数字游戏Ⅱ

\(f[i][j][k]\) 表示前\(i\)位已经摆好，最高位为\(j\), 所有位数字余数为\(k\)的方案数。

固 \(f[i][x][k] = \sum \limits_{j = 0}^9 f[i][j][mod(k - x, P)]\)

#include <bits/stdc++.h>

using i64 = long long;

const int N = 12, M = 110;

int P;
int f[N][10][M];

int mod(int x, int y) {
	return (x % y + y) % y;
}

void init() {
	memset(f, 0, sizeof f);
	
	for (int i = 0; i <= 9; i ++) f[1][i][i % P] ++;

	for (int i = 2; i < N; i ++) {
		for (int j = 0; j <= 9; j ++) {
			for (int k = 0; k < P; k ++) {
				for (int x = 0; x <= 9; x ++) {
					f[i][j][k] += f[i - 1][x][mod(k - j, P)];
				}
			}
		}	
	}
}

int dp(int n) {
	if (!n) return 1;

	std::vector<int> nums;

	while (n) nums.push_back(n % 10), n /= 10;

	int res = 0;
	int last = 0;

	for (int i = (int) nums.size() - 1; i >= 0; i --) {
		int x = nums[i];

		for (int j = 0; j < x; j ++) {
			res += f[i + 1][j][mod(-last, P)];
		}

		last += x;

		if (!i && last % P == 0) res ++;
	}

	return res;
}

int main() {
	int l, r;

	while (std::cin >> l >> r >> P) {
		init();
 		std::cout << dp(r) - dp(l - 1) << "\n";
	}
}

不要62

#include <bits/stdc++.h>

using i64 = long long;

const int N = 10;

int f[N][10];

void init() {
	for (int i = 0; i <= 9; i ++) {
		if (i != 4) {
			f[1][i] = 1;
		}
	}	

	for (int i = 2; i < N; i ++) {
		for (int j = 0; j <= 9; j ++) {
			if (j == 4) continue;
			for (int k = 0; k <= 9; k ++) {
				if (k == 4 || j == 6 && k == 2) continue;	
				f[i][j] += f[i - 1][k];	
			}
		}
	}
}

int dp(int n) {
	if (!n) return 1;

	std::vector<int> nums;

	while (n) nums.push_back(n % 10), n /= 10;

	int res = 0;
	int last = 0;

	for (int i = (int) nums.size() - 1; i >= 0; i --) {
		int x = nums[i];

		for (int j = 0; j < x; j ++) {
			if (j == 4 || last == 6 && j == 2) continue;
			
			res += f[i + 1][j];
		}

		if (x == 4 || last == 6 && x == 2) break;
        
        last = x;
        
		if (!i) res ++;
	}

	return res;
}

int main() {
	init();			

	int l, r;

	while (std::cin >> l >> r, l && r) {
		std::cout << dp(r) - dp(l - 1) << "\n";
	}
}

恨7不成妻

同样以树的方式思考，我们考虑如何设置转移方程

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

整数中某一位是 7；
整数的每一位加起来的和是 7 的整数倍；
这个整数是 7 的整数倍。

我们要找到不具有上述特性的数字

由于我们要求的是平方和，假设当前我们已经枚举到第\(i\)位，且最高位为数为\(j\)当前满足的数为\(jA_1,jA_2,jA_3,\dots jA_t\)，对其求平方和

\[\sum \limits_{i = 1}^t (jA_i)^2 \\ = t(j \times 10^{i - 1})^2 + 2(j \times 10^{i - 1})^2(\sum \limits_{i = 1}^t A_i) + \sum \limits_{i = 1}^t A_i^2 \\ \sum \limits_{i = 1}^t jA_i \\ = t(j\times 10^{i - 1}) \times \sum \limits_{i = 1}^{t}A_t \]

根据上述公式平方和需要由数量和一阶和和二阶和求得

设状态转移方程\(f[i][j][k][z]\) 表示考虑前\(i\)个数，当最高位\(i\)为\(j\)时，并且该数模7为\(k\) 的方案数量, 且数字相加为模\(7\)的余数为\(z\).

\[f[i][j][k][z].s0 = \sum \limits_{x = 0 \space and \space \ne 7}^9 f[i - 1][x][mod(k - j * power, P)][mod(k - j, P)].s0 \bmod P \\ f[i][j][k][z].s1 = \sum \limits_{x = 0 \space and \space \ne 7}^9 f[i - 1][x][mod(k - j * power, P)][mod(k - j, P)].s0 \times (j \times 10 \times power) \times f[i - 1][x][mod(k - j * power, P)][mod(k - j, P)].s1\\ 二阶和按找上述公式继续展开，略过了 \]

另外这道算是数位DP的难题了，对于取模有很高的要求，需要时刻防止数的溢出（因为有多个乘法，并且数都很大），同理其实这道题出三次方，也可以根据前面的数量和一次方二次方推导。

#include <bits/stdc++.h>

using i64 = long long;

const int N = 20, P = 1e9 + 7;

struct F {
	int s0, s1, s2;
} f[N][10][7][7];

int power7[N], power9[N];

int mod(i64 x, int y) {
	return (x % y + y) % y;
}

void init() {
	for (int i = 0; i <= 9; i ++) {
		if (i == 7) continue;
		auto& v = f[1][i][i % 7][i % 7];
		v.s0 ++;
		v.s1 += i;
		v.s2 += i * i;
	}

	i64 power = 10;

	for (int i = 2; i < N; i ++, power *= 10) {
		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;

						auto &v1 = f[i][j][a][b], &v2 = f[i - 1][k][mod(a - j * power, 7)][mod(b - j, 7)];

						v1.s0 = mod((v1.s0 + v2.s0), P);
						v1.s1 = mod(v1.s1 + v2.s1 + j * (power % P) % P * v2.s0, P);
						v1.s2 = mod(v1.s2 +
							j * j * (power % P) % P * (power % P) % P * v2.s0 % P +
							2 * j * power % P * v2.s1 % P +
							v2.s2, P);
					}	
				}		
			}	
		}		
	}

	power7[0] = power9[0] = 1;

	for (int i = 1; i < N; i ++) {
		power7[i] = power7[i - 1] * 10 % 7;	
		power9[i] = power9[i - 1] * 10ll % P;
	}
}

F get(int i, int j, int a, int b) {
	int s0 = 0, s1 = 0, s2 = 0;


	for (int x = 0; x < 7; x ++) {
		for (int y = 0; y < 7; y ++) {
			if (x == a || y == b) continue;
			auto v = f[i][j][x][y];
			s0 = (s0 + v.s0) % P;	
			s1 = (s1 + v.s1) % P;
			s2 = (s2 + v.s2) % P;
		}
	}

	return {s0, s1, s2};		
}

int dp(i64 n)
{
    if (!n) return 0;

   	i64 backup_n = n % P;
    std::vector<int> nums;
    while (n) nums.push_back(n % 10), n /= 10;

    i64 res = 0;
    i64 last_a = 0, last_b = 0;
    for (int i = nums.size() - 1; i >= 0; i -- )
    {
        int x = nums[i];
        for (int j = 0; j < x; j ++ )
        {
            if (j == 7) continue;
            int a = mod(-last_a * power7[i + 1], 7);
            int b = mod(-last_b, 7);
            auto v = get(i + 1, j, a, b);
            res = mod(
                res + 
                (last_a % P) * (last_a % P) % P * power9[i + 1] % P * power9[i + 1] % P * v.s0 % P + 
                v.s2 + 
                2 * last_a % P * power9[i + 1] % P * v.s1,
            P);
        }

        if (x == 7) break;
        last_a = last_a * 10 + x;
        last_b += x;

        if (!i && last_a % 7 && last_b % 7) res = (res + backup_n * backup_n) % P;
    }

    return res;
}


int main() {
	init();

	int _;

	std::cin >> _;

	while (_ --) {
		i64 l, r;
		std::cin >> l >> r;
		std::cout << mod(dp(r) - dp(l - 1), P) << "\n";
	}

	return 0;
}

计数问题

#include <bits/stdc++.h>

using i64 = long long;

const int N = 11;


i64 f[N][N], g[N][N];

i64 power[N];

void init() {
	power[0] = 1;

	for (int i = 1; i <= 9; i ++) power[i] = power[i - 1] * 10;

	// f[i][j] 表示含有前导0, 0~(i个9)
	for (int i = 0; i <= 9; i ++) f[1][i] = 1;

	for (int i = 2; i <= 9; i ++) {
		for (int j = 0; j <= 9; j ++) {
			f[i][j] = 10 * f[i - 1][j] + power[i - 1];
		}
	}

	// g[i][j] 表示不含有前导0, 0~(i个9)

	// g[i][j] = 9 * f[i - 1][j] + power[i - 1] + g[i - 1][j];

	for (int i = 1; i <= 9; i ++) g[1][i] = 1;

	for (int i = 2; i <= 9; i ++) {
		g[i][0] = 9 * f[i - 1][0] + g[i - 1][0];
		for (int j = 1; j <= 9; j ++) {
			g[i][j] = 9 * f[i - 1][j] + power[i - 1] + g[i - 1][j];
		}
	}
}

std::vector<int> dp(int n) {
	std::vector<int> res(10, 0), last(10, 0);

	if (!n) return res;

	std::vector<int> nums;

	while (n) nums.push_back(n % 10), n /= 10;

	for (int i = 0; i <= 9; i ++) res[i] += g[(int) nums.size() - 1][i];

	for (int i = (int) nums.size() - 1; i >= 0; i --) {
		int x = nums[i];

		for (int j = (i == nums.size() - 1); j < x; j ++) {
			for (int k = 0; k <= 9; k ++) {
				res[k] += last[k] * power[i];
			}

			res[j] += power[i];

			for (int k = 0; k <= 9; k ++) {
				res[k] += f[i][k];					
			}
		}

		last[x] ++;

		if (!i) {
			for (int k = 0; k <= 9; k ++) {
				res[k] += last[k];
			}
		}
	}

	return res;
}

int main() {
	init();

	// for (int i = 0; i <= 9; i ++) {
	// 	std::cout << f[2][i] << "\n";
	// }

	int l, r;
	
	while (std::cin >> l >> r, l || r) {
		if (l > r) std::swap(l, r);

		std::vector<int> v1 = dp(r);
		
		std::vector<int> v2 = dp(l - 1);

		for (int i = 0; i <= 9; i ++) {
			std::cout << v1[i] - v2[i] << " \n"[i == 9];
		}
	}
}

posted on 2023-07-04 17:39 Jack404 阅读(15) 评论(0) 收藏举报

刷新页面返回顶部