不要62
Time Limit: 1000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 38443 Accepted Submission(s): 13958
杭州交通管理局经常会扩充一些的士车牌照，新近出来一个好消息，以后上牌照，不再含有不吉利的数字了，这样一来，就可以消除个别的士司机和乘客的心理障碍，更安全地服务大众。
不吉利的数字为所有含有4或62的号码。例如：
62315 73418 88914
都属于不吉利号码。但是，61152虽然含有6和2，但不是62连号，所以不属于不吉利数字之列。
你的任务是，对于每次给出的一个牌照区间号，推断出交管局今次又要实际上给多少辆新的士车上牌照了。
1 100 0 0
80
在纸上模拟了一上午，终于通过这道题感受到了数位DP的强大。
总之就是通过记忆化的过程递推。
思路一：
比如一个不含有不吉利数字的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已经非法，无论个位是什么都非法，所以直接丢掉了最后一个部分。
这就是数位DP的思想：
#include <bits/stdc++.h>
using namespace std;
int dp[8][10];
void init(void){
memset(dp,0,sizeof(dp));
dp[0][0] = 1;
int i,j,k;
for(i=1 ;i<8 ;i++){
for(j=0 ;j<10 ;j++){
for(k=0 ;k<10 ;k++)
if(j!=4 && !(j==6 && k == 2))
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 i,j,ans = 0;
for(i=len ;i>0 ;i--){
for(j=0 ;j<digit[i] ;j++){
if(j != 4 && !(digit[i+1] == 6 && j == 2))
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;
}
思路二：
我们还可以从反面思考。要求合法的数，如果我们能用DP的方法求出非法的数，总数 - 非法的数 = 合法的数。
所以我们可以设
dp[i][0] 长度为i的合法数
dp[i][1] 长度为i，最高位为2的合法数
dp[i][2] 长度为i的非法数
然后易得状态转移方程：
dp[i][0] = dp[i-1][0]*9 - dp[i-1][1]
(每一个合法数前加上0~9不包括4的9个数，仍为合法数,但注意若合法数的首位为2，那么我们需要减去其前一位加上6的情况)
dp[i][1] = dp[i-1][0]
(每一个合法数前加2 ，就成了一个长度加1，首位为2的合法数)
dp[i][2] = dp[i-1][2]*10 + dp[i-1][1] + dp[i-1][0]
(每一个非法数前加上0~9的十个数字仍非法) （每一个合法数前加4也非法） （每一个首位为2的合法数前加6便成为非法）
然后初始化DP之后，我们便得到了不同下标对应不同值得dp数组。
如何求小于n的合法数个数num呢
我们还是以n = 623进行举例。
我们先求小于n的非法数个数 ans。
首先：ans=0(初始化)。
623为三位数，那么以0~5开头的任意三位非法数都小于它，所以我们先加上这一部分：
即： ans += dp[2][2]*6 （所有的两位非法数前面加上0~5）
然后类似于思路一，ans再加上所有满足600<= x < 623 的非法数 x 的数目，然后就是我们要的值。
这时要分成两部分讨论：
一. 若求出满足 0<= y < 23的非法数y的数目，则其前面加上一个6，仍为非法数。
二.若求出满足 0<= y < 23的合法数y的数目，若 y 的首位为2，前面加上6，其也为非法数。
对于上述的第一部分，又需要分成两部分：
（1）. 长度为1的非法数，其前面加上0，1，则变成了一个小于23的两位非法数。
（2）. 长度为1的合法数，其前面加上4或者本身为2前加上6，使其变成非法数。（对于此例明显不存在这种合法数，但我们仍然需要有这个讨论的思想来解决一般性的例子）
对于上述的第一部分，又需要分成两部分：
.........
由此可见，这是一个递归的过程，所以我们可以用dfs 或者循环来实现，具体细节可见下面代码：（循环版本）
#include <bits/stdc++.h>
using namespace std;
int dp[10][3];
//dp[i][0] 长度为i的合法数
//dp[i][1] 长度为i，最高位为2的合法数
//dp[i][2] 长度为i的非法数
void init(void){
int i;
memset(dp,0,sizeof(dp));
dp[0][0] = 1;
for(i=1 ;i<7 ;i++){
dp[i][0] = dp[i-1][0]*9 - dp[i-1][1];
dp[i][1] = dp[i-1][0];
dp[i][2] = dp[i-1][2]*10 + dp[i-1][1] + dp[i-1][0];
}
}
int solve(int x){
int len = 0,digit[10];
int tem = x;
while(x){
digit[++len] = x%10;
x /= 10;
}
digit[len+1] = 0;
int ans = 0,i;
bool flag = false;
for(i=len ;i>0 ;i--){
ans += dp[i-1][2] * digit[i];
if(flag){
ans += dp[i-1][0] * digit[i];
}
if(!flag && digit[i]>4)
ans += dp[i-1][0];
if(!flag && digit[i+1] == 6 && digit[i]>2)
ans += dp[i][1];
if(!flag && digit[i]>6)
ans += dp[i-1][1];
if(digit[i] == 4 || (digit[i+1] == 6 && digit[i] == 2)){
flag = true;
}
}
return (tem - ans);
}
int main(){
int n,m;
init();
while(scanf("%d%d",&n,&m) != EOF && (n||m)){
cout << solve(m+1) - solve(n) << endl;
}
return 0;
}
另外就是可以直接用dfs来记忆化搜索：
#include <bits/stdc++.h>
using namespace std;
int dp[10][2],digit[10];
int dfs(int len,bool pre_6,bool limit){
if(len == 0)
return 1;
if(!limit && dp[len][pre_6] >= 0)
return dp[len][pre_6];
int i,ans = 0,num = (limit?digit[len]:9);
for(i=0 ;i<=num ;i++){
if(i==4 || (pre_6 && i==2))
continue;
ans += dfs(len-1,i==6,limit && i == num);
}
return (limit?ans:dp[len][pre_6] = ans);
}
int solve(int x){
int len = 0,i;
while(x){
digit[++len] = x%10;
x /= 10;
}
return dfs(len,false,true);
}
int main(){
int n,m;
memset(dp,-1,sizeof(dp));
while(scanf("%d%d",&n,&m) != EOF && (n||m)){
printf("%d\n",solve(m) - solve(n-1));
}
return 0;
}
如果是初学者，不能理解DP的思想也没关系，暴力也能过，但如果数据范围再大一点，比如m,n都是10^15左右，暴力就会超时，数位DP才是真正的正解。
暴力：
#include<stdio.h>
int f(int x);
int main(){
int i,sum=0,a[1000000];
for(i=1 ;i<1000000 ;i++){
if(f(i)){
sum++;
}
a[i]=sum;
}
int m,n,cnt;
while(scanf("%d%d",&m,&n) != EOF && (m||n)){
cnt = (n-m+1) - (a[n] - a[m-1]);
printf("%d\n",cnt);
}
return 0;
}
int f(int x){
while(x){
if(x % 10 == 4) return 1;
if(x %100 ==62) return 1;
x /=10;
}
return 0;
}
217
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
