数位dp BZOJ 2757: [SCOI2012]Blinker的仰慕者

2757: [SCOI2012]Blinker的仰慕者

Time Limit: 10 Sec   Memory Limit: 128 MB
Submit: 562   Solved: 133
[ Submit][ Status]

Description

 
Blinker 有非常多的仰慕者，他给每个仰慕者一个正整数编号。而且这些编号还隐藏着特殊的意义，即编号的各位数字之积表示这名仰慕者对Blinker的重要度。 现在Blinker想知道编号介于某两个值A,B之间，且重要度为某个定值K的仰慕者编号和。 

Input

输入的第一行是一个整数N，表示Blinker想知道的信息个数。 
接下来的N行，每行有三个数，A,B,K。表示 Blinker想知道编号介于A和B之间的，
重要度为K的仰慕者的编号和。           

Output

输出N行，每行输出介于A和B之间，重要度为 K的仰慕者编号和。结果可能很大，
模上20120427。 

Sample Input

3
1 14 4
1 30 4
10 60 5
0<=K<=10^18

Sample Output

18
40
66
【样例解释】
第一组样例中，在 1到14之间各位数字之积等于 4的有 4和 14，故编号和为18。

HINT

【数据范围】 

对于20%的数据，保证：  2<=A<=B<=1000000000，1<=N<=30 

对于50%的数据，保证：2<=A<=B<=1000000000000000000，1<=N<=30 

对于100%的数据，保证：  2<=A<=B<=1000000000000000000，1<=N<=5000

题意：求出[A,B]中满足每个数字乘起来等于K的数的总和。

思路：首先我们看一下简化版，就是只求满足要求的数有多少个。看起来K很大是吧。其实要每个数字乘起来所得到的不同可能的数其实是不多的，经测试只有4*10^4 多个。这里完全可以离散化。 我们用num[i][j]表示i位数字，乘起来是j的数有多少个，那么根据num[i][j]可以推出 num[i+1][j*k] (0<=k<=9) ，那么我们就能很容易的得出[A,B]中满足条件的数字有多少个。但是问题是要求满足的数字加起来的总和。 我们不得不多加一个sum[i][j]表示i位数字，乘起来是j的数的总和。同样可以推出sum[i+1][j*k]. 那么我们运算的时候，如果我们确定了某个数的前缀是pre，那么满足要求的数的总和应该是 pre*10^x*num[x][K]+sum[x][K] , 因为对于每一个num[x][K]都能有这个前缀pre,所以我们可以这样求出来。 然后最后要注意的是K可能等于0，我觉得K=0和K！=0是不一样的，所以我分开来写了。。。

代码：

#include <vector>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <string.h>
#include <string>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
using namespace std;
#define rep(i,n) for(int i=0;i<n;++i)
#define clr(a,x) memset(a,x,sizeof(a))
#define LL long long
const LL mod=20120427;
const int N=131313; //44101
LL num[20][N];
LL sum[20][N];
LL id[N];
LL all_num[20],all_sum[20];
const LL inf=pow(9,18);
int len;
char bit[30];
LL pw[20];

inline int insert_hash(LL x)
{
    int k=x%N;
    while(id[k]!=-1) {
        ++k;
        if(k>=N) x=0;
    }
    id[k]=x;
    return k;
}

inline int ID(LL x)
{
    int k=x%N;
    while(id[k]!=x) {
        if(id[k]==-1) return -1;
        ++k; if(k>=N) k=0;
    }
    return k;
}

LL stk[N],tot;
void pre_init()
{
    clr(id,-1);
    clr(sum,0); clr(num,0);
    tot=0;
    pw[0]=1;
    for(int i=1;i<20;++i) pw[i]=pw[i-1]*10%mod;
    int r=0;
    for(int i=0;i<=9;++i) {
        if(ID(i)==-1) {
            insert_hash(i);
            stk[tot++]=i;
        }
        num[1][ID(i)]=1,sum[1][ID(i)]=i;
    }
    int tail=tot;
    for(int i=1;i<19;++i) {
        for(int j=0;j<tail;++j) {
            if(pow(9,i)<stk[j]) break;
            LL x=stk[j];
            int s=ID(x),t;
            for(LL k=0;k<=9;++k) {
                if(ID(x*k)==-1) {
                    insert_hash(x*k);
                    stk[tot++]=x*k;
                }
                t=ID(x*k);
                num[i+1][t]=(num[i+1][t]+num[i][s])%mod;
                sum[i+1][t]=(sum[i+1][t]+sum[i][s]+(k*(pw[i]*num[i][s])%mod)%mod)%mod;
            }
        }
        sort(stk,stk+tot);
        tail=tot;
    }
    clr(all_num,0); clr(all_sum,0);
    for(int i=0;i<20;++i) for(int j=0;j<N;++j) {
        all_num[i]=all_num[i]+num[i][j];
        if(all_num[i]>=mod) all_num[i]-=mod;
    }
    for(int i=0;i<20;++i) for(int j=0;j<N;++j) {
        all_sum[i]=all_sum[i]+sum[i][j];
        if(all_sum[i]>=mod) all_sum[i]-=mod;
    }
//   for(int i=0;i<20;++i) printf("%d: %lld\n",i,all_num[i]);
}

LL dfs_zero(int p,LL pre,bool zero,bool limit,bool first)
{
    if(p==0) return zero?pre:0;
    if(!limit&&!first) {
        if(!zero)  return ( (((pre*pw[p])%mod)*num[p][0])+sum[p][0])%mod;
        else return ((((pre*pw[p])%mod)*all_num[p])+all_sum[p])%mod;
    }
    int tail=limit?bit[p]-'0':9;
    LL ret=0;
    for(LL v=0;v<=tail;++v) {
        ret+=dfs_zero(p-1,(pre*10+v)%mod,zero||(v==0&&!first),limit&&v==tail,first&&v==0);
        if(ret>=mod) ret-=mod;
    }
    return ret;
}

LL dfs(int p,LL pre,LL K,bool limit,bool first)
{
    if(p==0) return K==1?pre:0;
    int t=ID(K);
    if(t==-1) return 0;
    if(!limit&&!first) {
        LL nm=num[p][t];
        LL sm=sum[p][t];
        return (((pre*nm)%mod*pw[p])+sm)%mod;
    }
    int tail=limit?bit[p]-'0':9;
    LL ret=0;
    for(LL v=0;v<=tail;++v) {
        if(first) {
            if(v==0) {
                ret+=dfs(p-1,(pre*10)%mod,K,limit&&v==tail,first);
                if(ret>=mod) ret-=mod;
            }
            else if(K%v==0) {
                ret+=dfs(p-1,(pre*10+v)%mod,K/v,limit&&v==tail,false);
                if(ret>=mod) ret-=mod;
            }
        }
        else if(v!=0&&(K%v)==0) {
            ret+=dfs(p-1,(pre*10+v)%mod,K/v,limit&&v==tail,false);
            if(ret>=mod) ret-=mod;
        }
    }
    return ret;
}

int main()
{
    pre_init();
    int T; cin>>T;
    while(T--) {
        LL x,y,K;
        scanf("%lld%lld%lld",&x,&y,&K);
        --x;
        sprintf(bit+1,"%lld",x);
        len=strlen(bit+1);
        reverse(bit+1,bit+1+len);
        LL ans=0;
        if(K==0) ans-=dfs_zero(len,0,false,true,true);
        else ans-=dfs(len,0,K,true,true);
        if(ans<0) ans+=mod;
        sprintf(bit+1,"%lld",y);
        len=strlen(bit+1);
        reverse(bit+1,bit+1+len);
        if(K==0) ans+=dfs_zero(len,0,false,true,true);
        else ans+=dfs(len,0,K,true,true);
        if(ans>=mod) ans-=mod;
        printf("%lld\n",ans);
    }
}