不要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;
}