数位DP
数位dp归为计数dp，通常需要统计一个区间[L,R]内满足某些限制条件的个数,会用到记忆化搜索
- 对于 [l,r] 区间问题，我们一般把他转化为两次数位dp,即找 [0,r] 和 [0,l-1] 两段，再将结果相减就得到了我们需要的 [l,r]
- 最高位限制：如：求小于等于345的数
- 最高位数填3,次高位数只能填0~3,最后一位随便填
- 前两位分别填3,4,最后一位只能填0~4
- 三位数分别填3,4,5
- 前导0
假设求[1,1000]之间的相邻位相差为2的数，0000是搜索的起点，搜索到0130时，0130会被判定为错的，而0130去掉前导0之后其实是符合条件的
Windy数
题目描述
不含前导零且相邻两个数字之差至少为 2 的正整数被称为 windy 数。windy 想知道，在 a 和 b 之间，包括 a 和 b ，总共有多少个 windy 数？
输入格式
输入只有一行两个整数，分别表示 a 和 b。
输出格式
输出一行一个整数表示答案。
迭代
d
p
[
i
]
[
j
]
dp[i][j]
dp[i][j]表示 i 位数最高位取j的符合条件的个数
d
p
[
i
]
[
j
]
=
∑
a
b
s
(
j
−
k
)
>
=
2
d
p
[
i
−
1
]
[
k
]
(
0
<
=
j
,
k
<
=
9
)
dp[i][j] =\sum_{abs(j-k)>=2} dp[i-1][k] (0<=j,k<=9)
dp[i][j]=∑abs(j−k)>=2dp[i−1][k](0<=j,k<=9)
比如dp[2][1]=dp[1][3]+dp[1][4]+dp[1][5]+…+dp[1][9]
- 首先对DP数组进行初始化
void init(int n)
{
memset(dp, 0, sizeof(dp));
//当只有一位数的时候，dp[1][i]=1
for (int i = 0; i <= 9; i++)
{
dp[1][i] = 1;
}
for (int i = 2; i < n; i++)//i位数
{
for (int j = 0; j <= 9; j++)//i位最高位取j
{
for (int k = 0; k <= 9; k++)//i-1位最高取k
{
if (abs(j - k) <= 2) continue;
dp[i][j] += dp[i - 1][k];
}
}
}
}
现在的dp数组已经处理完两位数相差2这个条件了,接着处理最大不超过n这个条件
- 先计算位数小于len的数的个数
//计算位数小于len的数的个数
for (int i = 1; i < len; i++)
{
for (int j = 1; j <=9; j++)
{
ans += dp[i][j];
}
}
- 计算最高位小于vec[len-1]的个数
//计算最高位小于vec[len-1]的数的个数
for (int i = 1; i <vec[len-1]; i++)
{
ans += dp[len][i];
}
- 接着计算次高位小于vec[len-2]…一直到最后一位小于vec[0]的个数
如果此时有两位连续的数确定,并且这两位数之差大于2,后面也就不用算了
//计算第i+1位为vec[i],第i位小于vec[i-1]的数的个数
for (int i = len - 1; i >= 1; i--)//i位数
{
for (int j = 0; j <vec[i-1]; j++)//最高位填j
{
//j是比vec[i-1]小的数，将j与vec[i]也就是上一位进行对比，找出i-1位可以填的数
if (abs(j - vec[i-1]) >= 2)
{
ans += dp[i][j];
}
}
//如果高位有两位数不符合规则，则整个数就不会是windy数
if (abs(vec[i] - vec[i-1]) >= 2)
break;
//到最后一位时,如果n的所有位都符合要求,那么答案个数加一
if(i==1) ans++
}
完整代码
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
using namespace std;
#define maxvex 35
int dp[maxvex][maxvex];//dp[i][j]表示 i 位数最高位取j的符合条件的个数
vector<int>vec;
void init(int n)
{
memset(dp, 0, sizeof(dp));
//当只有一位数的时候，dp[1][i]=1
for (int i = 0; i <= 9; i++)
{
dp[1][i] = 1;
}
for (int i = 2; i < n; i++)//i位数
{
for (int j = 0; j <= 9; j++)//i位最高位取j
{
for (int k = 0; k <= 9; k++)//i-1位最高取k
{
if (abs(j - k) <= 2) continue;
dp[i][j] += dp[i - 1][k];
}
}
}
}
int func(int n)
{
if (n == 0)
return 0;
while (n)
{
int x = n % 10;
vec.push_back(x);
n /= 10;
}
int len = vec.size();
init(len);
int ans = 0;
//计算位数小于len的数的个数
for (int i = 1; i < len; i++)
{
for (int j = 1; j <= 9; j++)
{
ans += dp[i][j];
}
}
//计算最高位小于vec[len-1]的数的个数
for (int i = 1; i <= 9; i++)
{
ans += dp[len][i];
}
//计算第i+1位为vec[i],第i位小于vec[len-i]的数的个数
for (int i = len - 1; i >= 1; i--)//i位数
{
for (int j = 0; j <vec[i-1]; j++)//最高位填j
{
if (abs(j - vec[i-1]) >= 2)
{
ans += dp[i][j];
}
}
if (abs(vec[i] - vec[i-1]) >= 2)
break;
}
return ans;
}
int main()
{
int a, b;
scanf("%d %d", &a, &b);
int resb = func(b);
int resa = func(a-1);
int ans = resb - resa;
printf("%d\n", ans);
system("pause");
return 0;
}
递归
变量
- pos:表示搜到第几位
- pre:表示前面那位数
- limit:最高位限制，如果为1表示前面所有位都已经是最高位
- zero:前导0，如果为0表示前面所有位都为0
暴力搜索
int dfs(int pos, int pre, int limit,int zero)//pos当前位置,pre前一位数,st判断前面是否全是0,limit最高位限制
{
if (pos<0) return 1;
int res = 0;
int ans = 0;
res = limit ? vec[pos] : 9;//如果有最高位限制，那么这一位只能最大只能取到vec[pos]
for (int i = 0; i <= res; i++)//遍历这一位可能的取值
{
if (abs(i - pre) >= 2) continue;
if (i==0&&zero)//下一位有前导0,不受相差2的限制
{
ans+=dfs(pos - 1, -2, limit&&res == i, 1);
}
else
{
ans+=dfs(pos - 1, i, limit&&res == i, 0);
}
}
return ans;
}
记忆化搜索
- 暴力搜索会超时
- dp[i][j]存储搜到第i位时前面为j，没有前导0也没有最高位限制的符合条件的数字个数
- 比如搜索345，第一位为0的往下搜索，会把dp[3][3]存储下来，而当第一位为1往下搜索时，又会碰到搜到第3位前面是3的情况
- 每一次递归dfs(pos,pre,limit,zero)其实就是在算dp[i][j]
- 之所以要排除有最高位限制，是因为有最高位限制时，dp[i][j]会不固定，比如345，前面两位是3，4，和前面两位是2，4，第二位都是4，但是最后一位能填的数的个数是不一样的。排除前导0也是一个道理
int dfs(int pos, int pre, int limit,int zero)//pos当前位置,pre前一位数,st判断前面是否全是0,limit最高位限制
{
if (pos > len) return 1;
if (!limit&&!zero&&dp[pos][pre] == -1) return dp[pos][pre];
int res = 0;//存储这一位能取到的最大可能值
int ans = 0;//存储符合条件的数的个数
res = limit ? a[pos] : 9;//如果有最高位限制，那么这一位只能最大只能取到vec[pos]
for (int i = 0; i <= res; i++)//遍历这一位可能的取值
{
if (abs(i - pre) >= 2) continue;
if (i&&zero)//下一位有前导0,随便取
{
ans+=dfs(pos + 1, -2, limit&&res == i, 0);
}
else
{
ans+=dfs(pos + 1, i, limit&&res == i, 1);
}
}
if (!limit&&!zero)
{
dp[pos][pre] = ans;
}
return ans;
}
B-number
题意：求1~n中包含13且能被13整除的数的个数。
思路
- dp[pos][mod][have]用于存储搜索过的状态
- 余数的求法：假设前三位为345，现在搜到第4位，赋值为i=6，已知mod=345%13如何知道3456%13的余数？
通过除法计算的过程可以知道 r m o d = （ m o d ∗ 10 + i ） % 13 rmod=（mod*10+i）\%13 rmod=（mod∗10+i）%13
变量
-
pos表示当前搜索到的数位
-
mod表示当前数余13的结果
-
have表示当前数是否含有13，具体表示为：
- have=2表示含有13 - have=1表示含有1 - have=0表示不含有1 -
limit表示是否有最高位限制
递归代码
int dfs(int pos, int mod, int have, int limit)
{
if (pos<0) return mod == 0 && have == 2;
if (!limit&&dp[pos][mod][have] != -1)
return dp[pos][mod][have];
int res, ans = 0;
res = limit ? vec[pos] : 9;
for (int i = 0; i <= res; i++)
{
int rmod = (mod * 10 + i) % 13;
int rhave=have;
//改变have的状态
if (have == 1 && i != 1) rhave = 0;
if (i == 1 && have == 0) rhave = 1;
if (i == 3 && have == 1) rhave = 2;
ans += dfs(pos-1, rmod, rhave, limit&&i == vec[pos]);
}
if (!limit) dp[pos][mod][have] = ans;
return ans;
}
完整代码
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
using namespace std;
#define maxvex 100
int dp[maxvex][maxvex][maxvex];//i表示搜索到的位数，j表示当前数对13取余，k表示是否含有13
vector<int>vec;
int dfs(int pos, int mod, int have, int limit)
{
if (pos<0) return mod == 0 && have == 2;
if (!limit&&dp[pos][mod][have] != -1)
return dp[pos][mod][have];
int res, ans = 0;
res = limit ? vec[pos] : 9;
for (int i = 0; i <= res; i++)
{
int rmod = (mod * 10 + i) % 13;
int rhave=have;
if (have == 1 && i != 1) rhave = 0;
if (i == 1 && have == 0) rhave = 1;
if (i == 3 && have == 1) rhave = 2;
ans += dfs(pos-1, rmod, rhave, limit&&i == vec[pos]);
}
if (!limit) dp[pos][mod][have] = ans;
return ans;
}
int main()
{
int n;
while (scanf("%d", &n) != EOF)
{
memset(dp, -1, sizeof(dp));
while (n)
{
vec.push_back(n % 10);
n /= 10;
}
int len = vec.size();
int ans = dfs(len - 1, 0, 0, 1);
printf("%d\n", ans);
vec.clear();
}
system("pause");
return 0;
}
扫一扫
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
