1081（度的数量）
题意：找出[L,R]区间内部满足条件的数量，条件是由互不相等的B为底的K次幂数组成。
分析：由于是由互不相等的B为底的K次幂数组成，可以把一个数当作B为底的展开项，且每一项的系数非0即1，因为如果大于1则超过了条件（互不相等）的要求。而求区间内满足的数，实际也可以基于前缀和的思想，求[1-R] 内满足条件的数减去[1-L-1]区域内满足条件的结果
数位DP的关键在于枚举各位上的数的情况，然后进行分类讨论，通常采用树结构进行分类讨论。
对于左分支满足条件的数目统计：由于当前第i-1已经填0，剩下i-1位当中还需要填K个1，所以满足条件的总数
C
i
−
1
k
C^k_{i-1}
Ci−1k；
此时统计数目问题改解成求组合数问题，由于本题组合数的范围较小（不会超过底35）所以直接用递推公式去做：
C
j
i
=
C
j
−
1
i
+
C
j
−
1
i
−
1
C^i_{j}=C^{i}_{j-1}+C^{i-1}_{j-1}
Cji=Cj−1i+Cj−1i−1,提前预处理出来组合数组，便于直接求取。
对于右分支，则每一次都需要前面几位已经用了几个1，如果当前还可以使用1，则继续使用，如果当前位是最后一位，且设置为1之后K个1用完，则整个右侧树链（原数n）也是一个合法的的数，需要累加上1。
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
const int N = 35;
int x, y, 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 == 0) return 0;
// 存放n的b进制的每一位
vector<int> nums;
// 获取n的b进制的每一位
while(n) nums.push_back(n % b), n /= b;
int res = 0;
// 设计一个last来存放之前已经有了几个1
int last = 0;
// 从高位向低位遍历，来统计数目
for(int i = nums.size() - 1; i >= 0 ; i--){
int x = nums[i];
// 只有当前位的数值大于0时，才有树的划分
if(x > 0){
// 1 第一种状态：当前位为0, 种类数就是剩下的几位中选k - last位为1
res += f[i][k - last];
if( x > 1){
// 2 第二种状态：当前位值大于1，此时只能选择x = 1这一种情况
res += f[i][k - last - 1];
// 3 其他情况已经违规了，不需要继续了
break;
}else{
// 3 第三种状态：当前值 == 1
last ++;
if(last > k) break;
}
}
// 如果当前数n也满足条件，res++
if (i == 0 && last == k) res ++;
}
return res;
}
int main()
{
init();
cin >> x >> y >> k >> b;
cout << dp(y) - dp(x - 1) << endl;
return 0;
}
1082（数字游戏）
题意：基本与1081相同，只是条件发生了变更：数必须满足从高位到地位非递减。
分析：同样需要先将求区间转成前缀和求两个函数的差值；按照数字的n位进行划分。
对于左侧分支，想要统计满足条件的数目：即在确定了n-1位上是k时，符合的总数应该时第n-2位上数>=k的总数加和。因此可以预处理出来总共i位，首位是j的满足条件的总数f[i][j]；
f
[
i
]
[
j
]
=
∑
k
=
j
9
f
[
i
−
1
]
[
k
]
f[i][j]=\sum_{k=j}^9 f[i-1][k]
f[i][j]=∑k=j9f[i−1][k]
对于右分支，当循环到第0位，且当前值大于等于前一位的值时，表示当前数n也满足条件，总数+1。
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
const int N = 32;
int a, b;
int f[N][10];
void init(){
for(int i = 0; i <= 9; i++) f[1][i] = 1;
for(int i = 2 ; i < N ; 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){
// n == 0 默认是一种
if(!n) return 1;
vector<int> nums;
while(n) nums.push_back(n % 10), n /= 10;
int res = 0;
int last = 0;
for(int i = nums.size() - 1; i >= 0 ; i--){
int x = nums[i];
for(int j = last; j < x ; j++){
res += f[i + 1][j];
}
if(x < last) break;
last = x;
if(!i) res ++;
}
return res;
}
int main()
{
init();
while(cin >> a >> b){
cout << dp(b) - dp(a - 1) << endl;
}
return 0;
}
1083（windy数）
此题基本与上面两题差不多，就时改了个条件，不进一步分析
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <cmath>
using namespace std;
const int N = 12;
int a, b;
int f[N][10];
void init(){
for(int i = 0; i <= 9; i++) f[1][i] = 1;
for(int i = 2; i < N ; 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 dp(int n){
if(!n) return 0;
vector<int> nums;
while(n) nums.push_back(n%10), n/=10;
int res = 0;
int last = -2;
for(int i = nums.size() - 1; i >= 0; i --){
int x = nums[i];
for(int j = (i == nums.size() - 1); j < x; j ++){
if(abs(last - j) >= 2){
res += f[i + 1][j];
}
}
if(abs(last - x) < 2) break;
last = x;
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();
cin >> a >> b;
cout << dp(b) - dp(a - 1) << endl;
return 0;
}
1084（数字游戏Ⅱ）
条件变更：数字必须满足各位数字之和 mod N 为 0。
分析：基于之前的学习，可以快速的构建出一个数位的树形结构，核心是如何快速的计算出左子树上满足条件的数目。如果第i位置上填上x，那么他可以从前所有其他位数之和+x mod N = 0的情况转移过来，进一步递推，设第i位之前各位之和是last，后面各位为rear，则（last + x + rear）mod N = 0，则 已知 （x + rear）mod N = -last mod N，所以第i位填上x的合法条件由所有余数为（-last mod N）的情况转移过来，所以可以设f[i][j][k]：表示共i位，首位填j，余数是k的总数，并事先预处理出所有的f。
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
const int N = 35, M = 110;
int a, b, p;
int f[N][10][M];
int mod(int x, int p){
return (x % p + p) % p;
}
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 t = 0; t < p; t ++){
for(int k = 0; k <= 9 ; k++){
f[i][j][t] += f[i-1][k][mod(t - j, p)];
}
}
}
}
}
int dp(int n){
if(!n) return 1;
vector<int> nums;
while(n) nums.push_back(n % 10), n /= 10;
int res = 0;
int last = 0; // last存放前面已经确定位数的加和
for(int i = nums.size() - 1; i >= 0; i--){
int x = nums[i];
for(int j = 0; j < x; j++){
// (last + after)mod p = 0 -> after mod p = -last mod p
res += f[i + 1][j][mod(-last, p)];
}
last += x;
if(!i && last % p == 0) res ++;
}
return res;
}
/**
* 条件变了，变成各位加和的取模N为0；
* f[i][j][k]: 表示共i位，首位是j，模后余数是k的总数
* f[i][j][k] += f[i-1][t][(k-j) % N]
*/
int main()
{
while(cin >> a >> b >> p){
init();
cout << dp(b) - dp(a - 1) << endl;
}
return 0;
}```
# 1085（不要62）
一样的思路，不分析，条件也很简单，不需要kmp
```cpp
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
const int N = 35;
int f[N][10];
int a, b;
void init(){
memset(f, 0, sizeof f);
for(int i = 0; i <= 9; i++){
if(i == 4) continue;
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;
vector<int> nums;
while(n) nums.push_back(n % 10), n /= 10;
int res = 0;
int last = 0;
for(int i = 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;
}
/**
* 条件变更：不包含4和连续的两位62的个数
* f[i][j]: 表示共有i位，首位为j，且满足条件的数目
*/
int main()
{
while(cin >> a >> b, a || b){
init();
cout << dp(b) - dp(a - 1) << endl;
}
return 0;
}
1409
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
