hdu 5787 K-wolf Number (数位DP ）

Problem Description

Alice thinks an integer x is a K-wolf number, if every K adjacent digits in decimal representation of x is pairwised different.
Given (L,R,K), please count how many K-wolf numbers in range of [L,R].

 

Input

The input contains multiple test cases. There are about 10 test cases.

Each test case contains three integers L, R and K.

1≤L≤R≤1e18
2≤K≤5

 

Output

For each test case output a line contains an integer.

 

Sample Input

  
  

   
   1 1 2
20 100 5
  
  

 

Sample Output

  
  

   
   1
72
  
  

 

（1）前导零的处理

代码1

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <cstring>
#include <cstdlib>
#include <string>
#include <cmath>
#include <set>
#include <map>
#include <bitset>

#define LL long long

#pragma comment(linker, "/STACK:102400000,102400000")

using namespace std;

const double eps = 1e-9;
const int inf = 0x3f3f3f3f;

int n,m;
LL l,r;
int k;

map<vector<int>,LL> dp[20];

int digit[29];
int tot=0;

bool ok(const vector<int> & ve)
{
    int last = ve[k-1];
    for(int i=0; i<k-1; i++)
    {
        if(last == ve[i])
            return false;
    }

    return true;
}


LL dfs(int pos,vector<int> vec,bool ismax,bool iszero)
{
    if(pos==0)
    {
        return 1LL;
    }

    if(!ismax && dp[pos].count(vec)) return dp[pos][vec];

    LL res=0;

    int ed = ismax? digit[pos] : 9;

    vector<int> nt;
    for(int i=1; i<vec.size(); i++)
    {
        if(!iszero)
            nt.push_back(vec[i]);
        else nt.push_back(-i);
    }

    for(int i=0; i<=ed; i++)
    {
        nt.push_back(i);

        if(ok(nt))
            res += dfs(pos-1,nt,ismax && i==ed,iszero && i==0);
        nt.pop_back();
    }

    return ismax ? res : dp[pos][vec] = res;

}

LL solve(LL x)
{
    tot=0;
    while(x)
    {
        digit[++tot] = x%10;
        x /=10;
    }

    vector<int> vec;
    for(int i=1; i<=k; i++) vec.push_back(-i);

    return dfs(tot,vec,true,true);

}

int main()
{


    for(int i=0; i<20; i++) dp[i].clear();

    while(scanf("%I64d%I64d%d",&l,&r,&k)!=EOF)
    {
        printf("%I64d\n",solve(r) - solve(l-1));
    }
    return 0;
}

代码2

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<map>
#define bug(x) cout<<#x<<" = "<<x<<endl;
using namespace std;

const int maxn = 20;
typedef __int64 LL;

LL l,r;
int k;

int tot=0;
int digit[20];

LL dp[20][110000];
LL mod;
int uu[10];

bool can(LL num,int len)
{
    int t;
    memset(uu,0,sizeof(uu));
    for(int i=0;i<len;i++)
    {
        t = num%10;
        num /=10;
        ++uu[t];
        if(uu[t]>=2) return false;
     }
     return true;
}

LL dfs(int pos,LL num,int len,int flag)
{
    if(pos<=0)
    {
        return 1;
    }

    if(flag && dp[pos][num]!=-1) return dp[pos][num];

    int la = flag ? 9 : digit[pos];

    LL ans=0;
    LL cc;

    for(int i=0;i<=la;i++)
    {
        cc = (num*10 + i)%mod;

        if( !can(cc,min(k,len+1)) ) continue;

        if(len==0)
        {
            if(i==0)
                ans += dfs(pos-1,cc,len,  flag||i!=la);
            else ans += dfs(pos-1,cc,min(k,len+1),flag||i!=la);
        }else{
            ans += dfs(pos-1,cc,min(k,len+1),flag||i!=la);
        }
    }
    if(flag)
        dp[pos][num]=ans;
    return ans;
}

LL solve(LL num)
{
    tot=0;
    while(num){digit[++tot]= num%10;num/=10;}

    return dfs(tot,0,0,0);
}

int main()
{
   
    while(scanf("%I64d%I64d%d",&l,&r,&k)!=EOF)
    { 
        memset(dp,-1,sizeof(dp));
        mod=1;
        for(int i=1;i<=k;i++)
            mod *=10;
        printf("%I64d\n", solve(r)-solve(l-1) );
    }

    return 0;
}