HDU2089 && HDU3652(数位DP)

记住一点，dfs中 return 1 的情况是你要的数

并去思考哪些状态标准是唯一决定后面情况数的，这些标准用来做为记忆化搜索的根据

HDU2089 (不要62和4的序列)

由于是不要62和4两个序列 如果写要62和4需要容斥一下，因此做的是不要某序列的操作
思路见注释

代码示例

//不要62 pre版本
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

ll a[20];//低位放低位  高位放高位
ll dp[20][2];//第二维有0,1两个状态 0表示不是6 ；1表示是6

ll dfs(int pos,int pre,int sta,bool limit)
{
    if(pos==-1) return 1;//上一个状态合法，所以返回1
    if(!limit && dp[pos][sta]!=-1){ //cout<<"当前位数为："<<pos<<"    前一位为："<<pre<<"我记忆化了"<<endl;
    return dp[pos][sta];}//注意必须要当前位无限制


    int up=limit ? a[pos] : 9;//看是否有限制 有的话就从0到a[pos]
    ll tmp=0;
    for(int i=0;i<=up;i++)//枚举当前位
    {
        if(pre==6 && i==2) continue;//不要62
        if(i==4) continue;//不要4
        tmp+=dfs(pos-1,i,i==6,limit && i==a[pos]);
        //只有当前面所有位都和边界相同了，最后一位才会limit
    }
    if(!limit) dp[pos][sta]=tmp;   //cout<<"当前位数为："<<pos<<"    前一位为："<<pre<<endl;
    return tmp;
}

ll solve(ll x)
{
    int pos=0;
    while(x)
    {
        a[pos++]=x%10;
        x/=10;
    }
    return dfs(pos-1,-1,0,true);//一开始是有限制的（最高位）,pre初始赋-1, sta赋0
}


int main()
{
    ios::sync_with_stdio(false);
    ll l,r;
    while(cin>>l)
    {
        memset(dp,-1,sizeof(dp));//这里的memset可以根据不同情况放在while外以降低复杂度，本题可以
        cout<<solve(l)<<endl;
    }
    return 0;
}

//不要62和4  have版本
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

ll a[20];
ll dp[20][3];//第二维有3个状态  0表示无62  1表示有6  2表示有62

ll dfs(int pos,int have,bool limit)
{
    if(pos==-1){
        return 1;
    }
    if(!limit&&dp[pos][have]!=-1) return dp[pos][have];
    int up=limit? a[pos] : 9;
    ll tmp=0;
    for(int i=0;i<=up;++i){
        int n_have=have;
        if(i==4) continue;
        if(have==0&&i==6) n_have=1;
        if(have==1&&i!=6) n_have=0;
        if(have==1&&i==2){
            n_have=2;
            continue;
        }
        tmp+=dfs(pos-1,n_have,limit && i==up);
    }
    if(!limit) dp[pos][have]=tmp;
    return tmp;
}

ll solve(ll x)
{
    int pos=0;
    while(x)
    {
        a[pos++]=x%10;
        x/=10;
    }
    return dfs(pos-1,0,true);//一开始是有限制的（最高位）
}

int main()
{
    ios::sync_with_stdio(false);
    ll l,r;
    while(cin>>l>>r&&(l|r))
    {
        memset(dp,-1,sizeof(dp));//这里的memset可以根据不同情况放在while外以降低复杂度，本题可以
        cout<<solve(r)-solve(l-1)<<endl;
    }
    return 0;
}

---

HDU3652（要13且各位之和满足一定条件）

思路见注释

（个人认为这种方法比上面更重要，更能体现出数位DP状态的思想）

代码示例

//要“13”并且和满足一定条件
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

int a[20];

ll dp[20][13][3];//存的是含有13的数
//第一维是位数、第二维状态为从最高位到当前位的和%13、第三位是是否含有1、3有 0 1 2三种状态
//0表示没有1   ;   1表示前面一位为1   ;  2表示有13了

ll dfs(int pos,int sum_mod,int have,bool limit)
{
    if(pos==-1){
        return sum_mod%13==0&&have==2;//都满足才返回1
    }
    if(!limit&&dp[pos][sum_mod][have]!=-1) return dp[pos][sum_mod][have];
    int up=limit?a[pos]:9;
    ll tmp=0;
    for(int i=0;i<=up;++i){
        int n_have=have;//下一个have(n_have)，由当前的have和i共同决定
        if(have==0&&i==1) n_have=1;//联想到数字逻辑中“状态”的转移 
        if(have==1&&i!=1) n_have=0;//i是1 则have不变 不是1变为0
        if(have==1&&i==3) n_have=2;//当然是3 变为2  这样就包含了所有情况
        tmp+=dfs(pos-1,(sum_mod*10+i)%13,n_have,limit&&up==i);//高位和乘10+低1位再膜
      //这样相当于*10+低位  、*10+低位   不停膜  等价于  最后膜
    }
    if(!limit) dp[pos][sum_mod][have]=tmp;
    return tmp;
}

ll solve(ll x)
{
    int pos=0;
    while(x)
    {
        a[pos++]=x%10;
        x/=10;
    }
    return dfs(pos-1,0,0,true);//一开始是有限制的（最高位）,且和为0，状态也为0
}

int main()
{
    ios::sync_with_stdio(false);
    ll n;
    while(cin>>n&&n)
    {
        memset(dp,-1,sizeof(dp));//这里的memset可以根据不同情况放在while外以降低复杂度，本题可以
        cout<<solve(n)-solve(0)<<endl;
    }
    return 0;
}