[BZOJ 1833] count 数字计数 数位DP(附数位DP总结)

题目传送门:【BZOJ 1833】

题目大意:给定两个正整数 a 和 b,求在 [a,b] 中的所有整数中,每个数码 (digit,指 0-9 ) 各出现了多少次。其中 a ≤ b ≤ 10 12

题目分析:

真正的题解在下面,前面为总结。

由题,观察这道题的题目性质及数据范围,那么,这道题用线性的 for 一遍肯定是不行的了;于是,我们考虑缩小数据处理范围。又因为这道题满足“前缀和相减”的性质,所以我们考虑使用数位 DP。

那么确定了方法之后,我们先要了解数位 DP 的做法。它通常是遍历每一位数,对每一位数及其之后的数统计答案。

以下的“第几位”指从低到高的位数。

实际上,数位 DP 有一个大体模型:
对这个数进行 dfs,通常,dfs 有两个必要的参数 dep(th) 和 limit;dep 表示现在遍历到第几位了,而 limit 表示这一位是否达到需要被处理到的极限。

[cpp] view plain copy
print ?
  1. int dfs(int dep,bool limit, … ){  
  2.     if (dep==0){  
  3.         return 1;  
  4.     }  
  5.     if (!limit){  
  6.         处理每个ans;   
  7.         return ans;  
  8.     }  
  9.       
  10.     int cnt=0,tot=0;  
  11.     int lim=(limit==true ? wei[dep] : 9);  
  12.       
  13.     for (int i=0;i<=lim;i++){  
  14.         cnt=0;  
  15.         cnt+=dfs(dep-1,limit && i==lim,lead && i==0);     
  16.         处理每个cnt;  
  17.         tot+=cnt;  
  18.     }  
  19.     return tot;  
  20. }  

假设现在没有其他的附加条件。
例如,对于一个数 3456,当最高位(千位)为 0,1,2 时,后面几位可以随意取值(0-9皆可);而当千位为 3 时,百位只能取到 0-4,所以这时我们要进入下一层查找。

当某一位取了一个值之后,接下来的几位都可以随意取值时,我们就可以将“可以随意取值”这个状态记录下来,这时我们就可以直接返回,避免浪费过多时间;所以,我们仅在无法随意取值的时候才进行递归查找操作。(当然也可以先预处理“可以随意取值”的状态)

而如果题目中有其他条件时(例如不能连续两位都是 1),我们可以增加一些新的参数;例如 prev 表示上一位取的数是多少,这时对于这个问题而言,如果上一个取了 1,那么这一位再取 1 将不是合法状态,所以此时我们就要把选 1 的情况排除掉(for 里面用一个 continue)。

那么对于这道题而言,它要求我们把每个数的出现次数统计出来,所以我们需要开两个桶,对于 [a,b],一个用来装 [1,a] 的答案,另一个用来装 [1,b] 的答案。同时,我们在 dfs 里面新增一个参数 lead,表示它是否为“存在前导 0 ”的数。
设目前的这个数的位数为 i ,令所有 i 位及以下的数(含前导 0)的答案为 fi ,则 fi=10fi1+10i1 ;又令所有 i 位及以下的数(不含前导 0)的答案为 gi ,则 gi=9gi1+gi1

如果 dfs 在当前位 dep 含有前导 0,对于“0”这个数,我们只统计 gdep 的答案;否则,我们统计 fdep 的答案。对于 1-9,由于它们不存在前导“0”的情况,直接统计 fdep 即可。根据前辈们的经验,最后输出的时候不能有多余的空格。

下面附上代码:

[cpp] view plain copy
print ?
  1. #include  
  2. #include  
  3. #include  
  4. #include  
  5. using namespace std;  
  6. typedef long long LL;  
  7. const int MX=13;  
  8. const int INF=0x3f3f3f3f;  
  9.   
  10. LL f[MX],g[MX];                 //f表示无前导0时,0-9的总方案数;  
  11.                                 //g表示有前导0时,0这个数的总方案数   
  12. int wei[MX],top;                //wei:每一位数的值   
  13.                                 //top:总位数   
  14. LL bucket[10],temp[10];         //bucket:桶,存下0-9每一个数出现的次数   
  15.                                 //temp: 临时的桶,开两个桶方便最后计算   
  16.   
  17. LL fastpow(LL a,LL b){          //快速幂   
  18.     LL r=1,base=a;  
  19.     while (b){  
  20.         if (b&1) r*=base;  
  21.         base*=base;  
  22.         b>>=1;  
  23.     }  
  24.     return r;  
  25. }  
  26. LL dfs(int dep,bool limit,bool lead){       //对每一位进行处理   
  27.                                 //dep:当前位  limit:是否达到这道题的限制  
  28.                                 //lead:是否有前导0   
  29.     if (dep==0){  
  30.         if (!lead) return 1;  
  31.         else return 0;  
  32.     }  
  33.     if (!limit){  
  34.         if (!lead) bucket[0]+=f[dep];  
  35.         else bucket[0]+=g[dep];  
  36.         for (int i=1;i<=9;i++){  
  37.             bucket[i]+=f[dep];  
  38.         }  
  39.         return fastpow(10,dep)*(!lead);  
  40.     }  
  41.     LL cnt=0,tot=0;             //cnt:这一位的计数  
  42.                                 //tot:之后所有位的计数   
  43.     int lim=(limit==true ? wei[dep] : 9);  
  44.       
  45.     for (int i=0;i<=lim;i++){  
  46.         cnt=0;  
  47.         cnt+=dfs(dep-1,limit && i==lim,lead && i==0);  
  48.         bucket[i]+=cnt;  
  49.         tot+=cnt;  
  50.     }  
  51.     return tot;  
  52. }  
  53.   
  54. int main(){  
  55.     LL a,b;  
  56.     scanf(”%I64d%I64d”,&a,&b);  
  57.     f[0]=f[1]=1;  
  58.     for (int i=2;i<=12;i++){  
  59.         f[i]=10*f[i-1]+fastpow(10,i-1);  
  60.         g[i]=9*f[i-1]+g[i-1];  
  61.           
  62.     }  
  63.       
  64.     LL tempa=a-1,tempb=b;               //根据前缀和计算   
  65.     int w=0;  
  66.       
  67.     while (tempa){  
  68.         wei[++w]=tempa%10;  
  69.         tempa/=10;  
  70.     }  
  71.     top=w;  
  72.     dfs(top,true,true);  
  73.     for (int i=0;i<=9;i++){  
  74.         temp[i]=bucket[i];  
  75.         bucket[i]=0;  
  76.     }  
  77.       
  78.     w=0;memset(wei,0,sizeof(wei));  
  79.       
  80.     while (tempb) {  
  81.         wei[++w]=tempb%10;  
  82.         tempb/=10;  
  83.     }  
  84.     top=w;  
  85.     dfs(top,true,true);  
  86.       
  87.     for (int i=0;i<=9;i++){              //统计答案   
  88.         printf(”%I64d”,bucket[i]-temp[i]);  
  89.         if (i!=9) printf(“ ”);  
  90.     }  
  91.     return 0;  
  92. }  

你可能感兴趣的:(各大OJ专题(POJ,BZOJ,hdu等),模板题,数位DP,总结篇)