康了好久数位dp的模板题也没康懂（哭唧唧，窝太菜惹QAQ
后来根据hdu 不要62康了手写版(附上连接http://acm.hdu.edu.cn/showproblem.php?pid=2089)也就是状态转移版的才明白，但是仍然不死心鸭，dfs的写起来太简单辽(还不是因为太懒
找了好久好久 才找到带解释的dfs版本
不要62
Time Limit: 1000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 64444 Accepted Submission(s): 25609
Problem Description
杭州人称那些傻乎乎粘嗒嗒的人为62（音：laoer）。
杭州交通管理局经常会扩充一些的士车牌照，新近出来一个好消息，以后上牌照，不再含有不吉利的数字了，这样一来，就可以消除个别的士司机和乘客的心理障碍，更安全地服务大众。
不吉利的数字为所有含有4或62的号码。例如：
62315 73418 88914
都属于不吉利号码。但是，61152虽然含有6和2，但不是62连号，所以不属于不吉利数字之列。
你的任务是，对于每次给出的一个牌照区间号，推断出交管局今次又要实际上给多少辆新的士车上牌照了。
Input
输入的都是整数对n、m（0<n≤m<1000000），如果遇到都是0的整数对，则输入结束。
Output
对于每个整数对，输出一个不含有不吉利数字的统计个数，该数值占一行位置。
Sample Input
1 100 0 0
Sample Output
80
首先数位dp之---------状态转移方法
状态转移参考https://blog.csdn.net/wubaizhe/article/details/54706356
比如一个不含有不吉利数字的4位数（下面称其为合法数），其后三位也一定是一个合法数。
我们用dp[i][j]保存以j开头，位数为i的合法数的数量，则:
dp[1][0] = 1；(0)
dp[1][1] = 1；(1)
dp[1][2] = 1；(2)
dp[1][3] = 1；(3)
dp[1][4] = 0；(4不合法，所以个数为0)
dp[1][5] = 1；（5）
dp[1][6] = 1；（6）
dp[1][7] = 1；（7）
dp[1][8] = 1；（8）
dp[1][9] = 1; （9）
下面来看位数为2的数
dp[2][0] = 9（00，01，02，03，05，06，07，08，09）
dp[2][1] = 9 (10, 11, 12, 13, 15, 16, 17, 18, 19)
......
dp[2][6] = 8 (特殊，因为62，64均不合法)
.......
dp[2][9] = 9
观察可知，dp[i][j]的3值，当j不为6时，就是 dp[i-1][0] + dp[i-1][1] +dp[i-1][2] +......+dp[i-1][9] (比如求1开头的合法两位数，那就是在所有的合法一位数前加个1)
易得状态转移方程：
dp[i][j] =∑ dp[i-1][k]（k=0~9 但不包括4），另外当j等于6时，不应加上dp[i-1][2]，否则就是62开头了。
dp[i][j]得到了，那么怎么得到小于一个数的所有合法数呢？
我们以623举例：
首先这是一个3位数，而且首位为6，那么以0，1，2，3，4，5开头的三位合法数一定小于它，则
num(小于623的合法数) = dp[3][5]+ dp[3][4] + dp[3][3]+ dp[3][2] dp[3][1]+ dp[3][0] + ....
然而我们发现有一些以6开头的三位数如 611 也满足，但并没有加上，所以我们接下来应该加上 600<= x < 623的所有合法数。
易知 所有x的首位都是6,那我们只需要得到 00<= y < 23的所有合法数，前面再加个6即可。
首先 首位为 0，1的二位合法数，前面加个6 是一定合法的,即 num += dp[2][0] + dp[2][1];
然后我们发现以2开头的二位合法数，前面加个6就产生了62，然后可以直接去掉。
终上所述：
num(小于623的合法数) = dp[3][5]+ dp[3][4] + dp[3][3]+ dp[3][2] dp[3][1]+ dp[3][0] + dp[2][0] + dp[2][1];
然后我们可以归纳 当要求一个小于三位数n的所有合法数num， 其公式为：（为方便理解，我们设n为xyz,即623为x=6,y=2,z=3）
num = dp[3][0] + dp[3][1] + ... + dp[3][x-1] + dp[2][0]+dp[2][1]+...+dp[2][y-1] + dp[1][0]+dp[1][1]+....+dp[1][z-1]；
而上面那个例子因为前两位为62已经非法，无论个位是什么都非法，所以直接丢掉了最后一个部分。
代码
#include <bits/stdc++.h>
using namespace std;
int dp[8][10];
void init(void){
memset(dp,0,sizeof(dp));
dp[0][0] = 1;
for(int i=1 ;i<8 ;i++){
for(int j=0 ;j<10 ;j++){
for(int k=0 ;k<10 ;k++)
if(j!=6)
dp[i][j] += dp[i-1][k];
}
}
}
int solve(int x){
int len = 0,digit[10];
while(x){
digit[++len] = x % 10;
x /= 10;
}
digit[len+1] = 0;
int ans = 0;
for(int i=len ;i>0 ;i--){
for(int j=0 ;j<digit[i] ;j++){
if(j != 6)
ans += dp[i][j];
}
if(digit[i] == 4 || (digit[i+1] == 6 && digit[i] == 2))
break;
}
return ans;
}
int main(){
init();
int n,m;
while(scanf("%d%d",&n,&m) != EOF && (m||n)){
cout << solve(m+1) - solve(n) << endl;
}
return 0;
}
dfs版本参考https://blog.csdn.net/yexiaohhjk/article/details/70162187
首先贴上（干货！带解释的模板
// pos = 当前处理的位置(一般从高位到低位)
// pre = 上一个位的数字(更高的那一位)
// status = 要达到的状态,如果为1则可以认为找到了答案,到时候用来返回,
// 给计数器+1。
// limit = 是否受限,也即当前处理这位能否随便取值。如567,当前处理6这位,
// 如果前面取的是4,则当前这位可以取0-9。如果前面取的5,那么当前
// 这位就不能随便取，不然会超出这个数的范围,所以如果前面取5的
// 话此时的limit=1,也就是说当前只可以取0-6。
//
// 用DP数组保存这三个状态是因为往后转移的时候会遇到很多重复的情况。
int dfs(int pos,int pre,int status,int limit)
{
//已结搜到尽头,返回"是否找到了答案"这个状态。
if(pos < 1)
return status;
//DP里保存的是完整的,也即不受限的答案,所以如果满足的话,可以直接返回。
if(!limit && DP[pos][pre][status] != -1)
return DP[pos][pre][status];
int end = limit ? DIG[pos] : 9;
int ret = 0;
//往下搜的状态表示的很巧妙,status用||是因为如果前面找到了答案那么后面
//还有没有答案都无所谓了。而limti用&&是因为只有前面受限、当前受限才能
//推出下一步也受限，比如567,如果是46X的情况,虽然6已经到尽头,但是后面的
//个位仍然可以随便取,因为百位没受限,所以如果个位要受限,那么前面必须是56。
//
//这里用"不要49"一题来做例子。
for(int i = 0;i <= end;i ++)
ret += dfs(pos - 1,i,status || (pre == 4 && i == 9),limit && (i == end));
//DP里保存完整的、取到尽头的数据
if(!limit)
DP[pos][pre][status] = ret;
return ret;
}
根据解释就很容易写出代码惹
个人认为 dfs里三个参数就阔以惹，pre和state阔以合二为一 直接判断 i是否等于6
各种数字只有符合和不符合两种状态，dp数组可以优化一下dp[pos][pre],pos代表当前位数 pre代表前一位(即高一位上的数)，pre位只需要判断是不是6 那么我们可以记录是不是6，不是6的话其他数效果都是一样的，所以pre为6的话可以等于1，其他数的话等于0
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ios ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
int dp[20][2];
int a[20];
int dfs(int pos,bool pre,bool limit)
{
if(pos==-1) return 1;
if(!limit&&dp[pos][pre]!=-1) return dp[pos][pre];
int ans=0;
int up=limit?a[pos]:9;
for(int i=0;i<=up;i++)
{
if(i==4||pre&&i==2)
continue;
ans+=dfs(pos-1,i==6,limit&&i==a[pos]);
}
if(!limit)
dp[pos][pre]=ans;
return ans;
}
int solve(int x)
{
int pos=0;
while(x)
{
a[pos++]=x%10;
x/=10;
}
return dfs(pos-1,0,true);
}
int main()
{
int n,m;
while(cin>>n>>m&&n&&m)
{
memset(dp,-1,sizeof dp);
cout<<(solve(m)-solve(n-1))<<endl;
}
}
练手：
牛客寒假训练题https://ac.nowcoder.com/acm/contest/329/G
给一个区间[l,r]找出其中不带6的数的个数（一个数带多个6只算一次）
数位dp我们可以算出含6的个数，然后区间总的-不含6的个数就是不含6的个数了
状态转移版：
#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll dp[20][20];
void init(void)
{
memset(dp,0,sizeof(dp));
dp[0][0] = 1;
for(int i=1 ;i<20 ;i++)
{
for(int j=0 ;j<10 ;j++)
{
for(int k=0 ;k<10 ;k++)
if(j!=6)
dp[i][j] += dp[i-1][k];
}
}
}
ll solve(ll x)
{
ll len = 0,digit[20];
while(x)
{
digit[++len] = x % 10;
x /= 10;
}
digit[len+1] = 0;
ll ans = 0;
for(int i=len ;i>0 ;i--)
{
for(int j=0 ;j<digit[i] ;j++)
{
if(j != 6)
ans += dp[i][j];
}
if(digit[i] == 6)
break;
}
return ans;
}
int main()
{
init();
ll n,m;
scanf("%lld%lld",&n,&m);
cout << m-n+1-(solve(m+1) - solve(n)) << endl;
return 0;
}
dfs版：
这里不需要其他判断，只要看是否含6，所以dfs就只用了两个参数
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ios ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
ll dp[20];
ll a[100];
ll dfs(int pos,bool limit)
{
if(pos==-1)
return 1;
if(!limit&&dp[pos]!=-1)
return dp[pos];
int up=limit?a[pos]:9;
ll ans=0;
for(int i=0;i<=up;i++)
{
if(i==6)
continue;
ans+=dfs(pos-1,limit&&i==a[pos]);
}
if(!limit)
dp[pos]=ans;
return ans;
}
ll solve(ll x)
{
int pos=0;
while(x)
{
a[pos++]=x%10;
x/=10;
}
return dfs(pos-1,true);
}
int main()
{
ios;
memset(dp,-1,sizeof(dp));
ll a,b;
cin>>a>>b;
cout<<b-a+1-(solve(b)-solve(a-1))<<endl;
}
扫一扫
1659
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
