不要62 HDU - 2089

最新推荐文章于 2023-03-24 20:16:01 发布

elbadaernu

最新推荐文章于 2023-03-24 20:16:01 发布

阅读量313

点赞数

分类专栏：数位dp

数位dp 专栏收录该内容

8 篇文章

订阅专栏

不要62 HDU - 2089

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

题目大意：多组数据，每次给定区间[n,m]，求在n到m中没有“62“或“4“的数的个数。

如62315包含62，88914包含4，这两个数都是不合法的。（0<n≤m<1000000）

思路1：试想：我们如果能有一个函数count(int x)，可以返回[0,x]之间符合题意的数的个数。那么是不是直接输出count(m)-count(n-1)就是答案？

好，那么下面我们的关注点就在于怎么做出这个函数。我们需要一个数组。（dp原本就是空间换时间）

我们设一个数组f[i][j]，表示i位数，最高位是j的数，符合题意的数有多少个。
比如f[1][2]=1; f[1][4]=0; f[2][6]=8 (60,61,63,64,65,66,67,68,69).

我们先不关注这个f有什么用，我们先关注f本身怎么求。首先f[1][i]=0(if i==4),f[1][i]=1(if i!=4) (0<=i<=9)。这一步是很显然的，那么根据这个题的数据范围，只需要递推到f[7][i]就够用了。那么稍微理解一下，可以想出递推式：

　　f[i][j]=

　　　　if (j==4) f[i][j]=0

　　　　else if (j!=6) f[i][j]=Σf[i-1][k] (k=0,1,2,3,4,5,6,7,8,9)

　　　　else if (j==6) f[i][j]=Σf[i-1][k] (k=0,1,3,4,5,6,7,8,9)

上面的式子也是很显然的，如果觉得不显然可以这样想：i位数，最高位是j的符合条件的数，如果j是4，肯定都不符合条件（因为题目不让有4），所以直接是0；如果j不是6，那么它后面随便取，只要符合题意就可以，所以是f[i-1][k],k可以随便取的和；如果j是6，后面只要不是2就行，所以是f[i-1][k],k除了2都可以，求和。

这里要说明一下，认为00052是长度为5，首位为0的符合条件的数，052是长度为3首位为0符合条件的数。

那么现在我们已经得到了f数组，再重申一下它的含义：i位数，最高位是j的数，符合题意的数有多少个。

现在我们就要关注怎么利用f数组做出上面我们说的那个函数count(int x)，它可以求出[0,x]中符合题意的数有多少个。

那么我们做这样一个函数int solve(int x) 它可以返回[0,x)中符合题意的有多少个。那么solve(x+1)实际上与count(x)是等价的。

那么现在问题转化成了：小于x，符合题意的数有多少个？

很简单，既然小于，从最高位开始比，必定有一位要严格小于x（前面的都相等）。所以我们就枚举哪一位严格小于（前面的都相等）。

假设我们现在把x分成了a1,a2,…,aL这样一个数组，长度为L，aL是最高位。

那么结果实际上就是这样：长度为L，最高位取[0,aL-1]的所有的符合题意数的和；再加上长度为L-1，最高位取aL，次高位取[0,aL-1-1]的所有符合题意数的和；再加上……；一直到第一位。

上面有一句话之所以标粗体，是因为这句话并不是对的，但是为了好看，就先这样写着。因为我们还需要考虑这种情况：最高位aL如果是4，那么这句话直接就可以终止了，因为粗体这句话前面的那句话“最高位取aL”是不能成立的。还要考虑这种情况：最高位aL如果是6，那么这里并不是能取[0,aL-1-1]的所有（不能取2）。加上这些条件之后就很严谨了。

把上面的汉字对应到题目里，就是我们前面求出来的f[L][0..aL-1] f[L-1][0..aL-1-1]，所以稍加思索之后就能写出程序了。

代码如下

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector>
#include<cmath>
#include<string>
#define LL long long  
using namespace std;

LL dp[10][10];
LL n,m; 

void handle()
{
    for(int i=0;i<10;i++)
    {
        if(i!=4)
        dp[1][i]=1;
        for(int i=2;i<=9;i++)
        {
            for(int j=0;j<=9;j++)
            {
                dp[i][j]=0;
                if(j==4)
                {
                    dp[i][j]=0;
                    continue;
                }
                else 
                {
                    if(j==6)
                    {
                        for(int k=0;k<=9;k++)
                        {
                            if(k==2)
                            continue;
                            dp[i][j]+=dp[i-1][k];
                        }
                    }
                    else 
                    {
                        for(int k=0;k<=9;k++)
                        dp[i][j]+=dp[i-1][k];
                    }
                }
            }
        }
    }
}
LL solve(LL N)
{
    int num[10];
    memset(num,0,sizeof(num));
    int size=0;
    LL sum=0;
    while(N)
    {
        num[++size]=N%10;
        N/=10;
    }
    int flag=0;
    for(int i=size;i>=1;i--)
    {
        if(flag)
        break;
        for(int j=num[i]-1;j>=0;j--)
        {
            if(num[i+1]==6&&j==2)
            {
                continue;
            }
            sum+=dp[i][j];
        }
        if(num[i]==4||(num[i]==2&&num[i+1]==6))
        flag=1;
    }
    return sum;
}
int main()  
{  
    memset(dp,0,sizeof(dp));
    handle();
    while(1)
    {
        cin>>n>>m;
        if(!(n+m))
        break;
        LL l,r;
        r=solve(m+1);
        l=solve(n);
        cout<<r-l<<endl;
    }
    return 0;  
}

思路2：

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string.h>
using namespace std;
int dp[10][3];
/*
 * dp[i][0],表示长度为i，不存在不吉利数字
 * dp[i][1],表示长度为i,不存在不吉利数字，且最高位为2
 * dp[i][2],表示长度为i,存在不吉利数字
 */
void init()
{
    dp[0][0]=1;dp[0][1]=0;dp[0][2]=0;
    for(int i=1;i<=6;i++)
    {
        dp[i][0]=dp[i-1][0]*9-dp[i-1][1];//在最高位加上除4以外的9个数字，但要减掉2之前加上6
        dp[i][1]=dp[i-1][0];//在不含不吉利数字的最高位加上2
        dp[i][2]=dp[i-1][2]*10+dp[i-1][0]+dp[i-1][1];
        //在已有不吉利数字前加任意数字，或者无不吉利数字的最高位加4，或者在2前面加6
    }
}
int bit[10];
int solve(int n)
{
    int len=0;
    int tmp=n;
    while(n)
    {
        bit[++len]=n%10;
        n/=10;
    }
    bit[len+1]=0;
    int ans=0;
    bool flag=false;
    for(int i=len;i>=1;i--)
    {
        ans+=dp[i-1][2]*bit[i];
        if(flag)//高位已经出现4或者62，后面随意
            ans+=dp[i-1][0]*bit[i];
        if(!flag&&bit[i]>4)
            ans+=dp[i-1][0];
        if(!flag&&bit[i+1]==6&&bit[i]>2)
            ans+=dp[i][1];
        if(!flag&&bit[i]>6)
            ans+=dp[i-1][1];
        if(bit[i]==4||(bit[i+1]==6&&bit[i]==2))
            flag=true;
    }
    if(flag)ans++;//这个数本身
    return tmp-ans;
}
int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    init();
    int n,m;
    while(scanf("%d%d",&n,&m)==2)
    {
        if(n==0 && m==0)break;
        printf("%d\n",solve(m)-solve(n-1));
    }
    return 0;
}

思路3：dfs

#include<iostream>
#include<algorithm>
#include<string>
#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#include<cstring>
#include<cmath>
#define LL long long  
#define ULL unsigned long long  
using namespace std;
int dp[1005][2]; //dp[i][j],j=0表示末尾不为6，j=1表示末尾为6
int digit[1005];
int n,m;  

int dfs(int l, int  flag,int jud) {
    if ( l==0) return 1;
    if ( !jud && dp[l][flag]!=-1) return dp[l][flag];
    int ans = 0;
    int nex = jud ? digit[l] : 9;
    for (int i = 0; i <=  nex; i++)
    {
       if(i==4||(flag&&i==2))
       continue;
       ans += dfs( l-1 ,i==6 , jud && i==nex );
    }
    if(!jud)
    {
        dp[l][flag]=ans;
    }
    return ans;
}
int f(int num){
    memset(dp,-1,sizeof(dp));

    int tol = 0;
    while(num){
        digit[++tol]=num%10;
        num=num/10;
    }
    return dfs(tol,false,true);
}

int main()
{
    while(scanf("%d%d",&n,&m)!=EOF&&(n+m))
    {
        printf("%d\n",f(m)-f(n-1));
    }
    return 0; 
}