数位DP复习小结

转载请注明原文地址http://www.cnblogs.com/LadyLex/p/8490222.html

之前学数位dp的时候底子没打扎实

虚的要死

这次正好有时间……刷了刷之前没做的题目

感觉自己脑洞不太够……比较经典的题或者见过的类似模型就能自己推出来，但是没有见过的模型就虚的要死（比如二进制数位DP）

感谢WQ的帮助，让我对数位DP的理解逐渐加深

那么我们总结一下这次做的题目……

bzoj4521

　　记忆化搜索即可，水爆

 #include <cstring>
 #include <cstdio>
 using namespace std;
 #define RG register
 #define LL long long
 int bin[],cnt;
 LL poww[],f[][][][][][];
 inline int min(int a,int b){return a<b?a:b;}
 inline int max(int a,int b){return a>b?a:b;}
 inline LL dfs(int st,int pre,int comb,int maxcomb,bool have8,bool have4,bool limit)
 {
     if(st==)return maxcomb==;
     if(!limit&&f[st][pre][comb][maxcomb][have8][have4]!=-)
         return f[st][pre][comb][maxcomb][have8][have4];
     LL ret=;
     RG int i,tmp,lim=(limit)?bin[st]:;
     for(i=;i<lim;++i)
     {
         tmp=min((pre==i)?comb+:,);
         if(i==)
         {
             if(!have8)ret+=dfs(st-,i,tmp,max(tmp,maxcomb),,,);
         }
         else if(i==)
         {
             if(!have4)ret+=dfs(st-,i,tmp,max(tmp,maxcomb),,,);
         }
         else ret+=dfs(st-,i,tmp,max(tmp,maxcomb),have8,have4,);
     }
     if(limit)
     {
         tmp=min((pre==i)?comb+:,);
         if(i==)
         {
             if(!have8)ret+=dfs(st-,i,tmp,max(tmp,maxcomb),,,);
         }
         else if(i==)
         {
             if(!have4)ret+=dfs(st-,i,tmp,max(tmp,maxcomb),,,);
         }
         else ret+=dfs(st-,i,tmp,max(tmp,maxcomb),have8,have4,);
     }
     if(!limit)f[st][pre][comb][maxcomb][have8][have4]=ret;
     return ret;
 }
 inline LL calc(LL len)
 {
     LL ret=;cnt=;
     while(len)bin[++cnt]=len%,len/=;
     for(RG int i=;i<bin[];++i)ret+=dfs(,i,,,i==,i==,);
     return ret+dfs(,bin[],,,bin[]==,bin[]==,);
 }
 int main()
 {
     LL l,r,ans;RG int i;
     for(poww[]=i=;i<=;++i)poww[i]=poww[i-]*;
     scanf("%lld%lld",&l,&r);
     memset(f,-,sizeof(f)),ans=calc(r);
     if(l>1e10)ans-=calc(l-);
     printf("%lld\n",ans);
 }

BZOJ4521

bzoj4029

　　假装他是数位dp的小模拟

 #include <cstdio>
 #include <cstring>
 using namespace std;
 #define RG register
 #define LL long long
 int br[],bl[],lr,ll,_10[];
 int main()
 {
     RG int pos,i,j,l,r,tmp,t,ans;
     scanf("%d",&t);
     for(_10[]=,i=;i<=;++i)_10[i]=_10[i-]*;
     while(t--)
     {
         scanf("%d%d",&l,&r),--l;
         ll=lr=;
         tmp=r;while(tmp)br[++lr]=tmp%,tmp/=;
         tmp=l;while(tmp)bl[++ll]=tmp%,tmp/=;
         if(lr!=ll)
         {
             if(l<*_10[ll])ans=*_10[ll];
             else if(*_10[ll+]<=r)ans=*_10[ll+];
             else if(bl[ll]==)ans=_10[ll+];
             else ans=_10[ll]*(bl[ll]+);
         }
         else
         {
             pos=ll;ans=;
             while(bl[pos]==br[pos]&&pos)ans=ans*+bl[pos],--pos;
             if(pos)
             {
                 if(bl[pos]<&&<=br[pos])ans=(ans*+)* _10[pos];
                 else ans=(ans*+bl[pos]+)* _10[pos];
             }
         }
         printf("%d\n",ans);
     }
 }

BZOJ4029

bzoj3209

　　从低位往高位DP，带个组合数乱搞，比较水,没有打

bzoj3329

　　两边同时异或一下x，然后由于异或是不进位的加法，所以发现性质是没有相邻的1，dp即可

 #include <cstring>
 #include <cstdio>
 using namespace std;
 #define mod 1000000007
 #define RG register
 #define LL long long
 namespace work1
 {
     LL f[][];int bin[],len;
     inline void init()
     {
         f[][]=,f[][]=;
         for(RG int i=;i<=;++i)
             f[i][]=f[i-][]+f[i-][],f[i][]=f[i-][];
     }
     inline LL dfs(int st,int pre,bool lim)
     {
         if(st==)return ;
         if(!lim)return pre?f[st][]:f[st][]+f[st][];
         if(bin[st])
             return pre?dfs(st-,,):(dfs(st-,,)+dfs(st-,,));
         return dfs(st-,,);
     }
     inline LL work(LL n)
     {
         if(!n)return ;
         len=;while(n)bin[++len]=n&,n>>=;
         return dfs(len-,,)+dfs(len-,,)-;
     }
 }
 namespace work2
 {
     struct matrix
     {
         int a[][];
         inline void clear(){memset(a,,sizeof(a));}
         inline void init(){memset(a,,sizeof(a));for(RG int i=;i<;++i)a[i][i]=;}
         inline matrix operator * (const matrix &b)const
         {
             RG int i,j,k;
             matrix c;c.clear();
             for(i=;i<;++i)
                 for(k=;k<;++k)if(a[i][k])
                     for(j=;j<;++j)if(b.a[k][j])
                         c.a[i][j]=(c.a[i][j]+(LL)a[i][k]*b.a[k][j])%mod;
             return c;
         }
         inline void print()
         {
             for(RG int i=;i<;++i,printf("\n"))
                 for(RG int j=;j<;++j)
                     printf("%d ",a[i][j]);
         }
     }d,t;
     inline void init()
     {
         d.clear(),d.a[][]=d.a[][]=d.a[][]=d.a[][]=d.a[][]=;
     }
     inline matrix quick_mod(matrix di,LL mi)
     {
         matrix ret;ret.init();
         for(;mi;mi>>=,di=di*di)if(mi&)ret=ret*di;
         return ret;
     }
     inline int work(LL n)
     {
         t.clear(),t.a[][]=t.a[][]=,t=t*quick_mod(d,n);
         return t.a[][];
     }
 }
 int main()
 {
     RG int i,j,t;LL n;
     scanf("%d",&t);
     work1::init(),work2::init();
     while(t--)
         scanf("%lld",&n),printf("%lld\n%d\n",work1::work(n),work2::work(n));
 }

BZOJ3329

bzoj1799

　　打表发现数位之和很少，枚举数位之和，但是我没想到dp的定义……

　　然后看了一下题解的数组定义，难度适中吧……没有那么难，但是自己还是没想出来

　　那个维护当前值然后每次cur=cur×10+i的很巧妙，没想出来……

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 using namespace std;
 #define RG register
 #define LL long long
 int bin[];
 inline int min(int a,int b){return a<b?a:b;}
 inline int max(int a,int b){return a>b?a:b;}
 int mod,mark[][][][];
 LL f[][][][];
 inline LL dfs(int st,int sum,int cur,bool lim)
 {
     if(st==)return cur==&&sum==;
     if(mark[st][sum][cur][lim]==mod)return f[st][sum][cur][lim];
     mark[st][sum][cur][lim]=mod;LL ret=;
     RG int i,l=max(,sum-(st-)* ),r=min( sum+,(lim?bin[st]:) );
     for(i=l;i<r;++i)ret+=dfs(st-,sum-i,(cur*+i)%mod,);
     if(lim && sum>=bin[st] )
         ret+=dfs(st-,sum-bin[st],(cur*+bin[st])%mod,);
     return f[st][sum][cur][lim]=ret;
 }
 inline LL calc(LL n)
 {
     RG int cnt=;LL ret=;
     while(n)bin[++cnt]=n%,n/=;
     memset(mark,,sizeof(mark));
     for(mod=;mod<=;++mod)ret+=dfs(cnt,mod,,);
     return ret;
 }
 int main()
 {
     RG int i,j;LL l,r;
     scanf("%lld%lld",&l,&r);
     printf("%lld\n",calc(r)-calc(l-));
 }

BZOJ1799

bzoj1183+bzoj2713

　　这个和之前那个淘金很像……先预处理乘积，后面那个我一开始一直在想像上面1799的搞法带着乘积走

　　然后发现不行，最后得到了提示，对于每一个乘积x，我去查询l/x,r/x区间内乘积为x的数就行了

　　这个转化和之前数学上那个gcd很像：d|ij <==> d/gcd(i,d) | j

　　啊我好蠢啊

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <cstdlib>
 using namespace std;
 #define RG register
 #define LL long long
 #define L 440000
 #define UL 44000
 int bin[],len,cnt;
 LL _9[],mul[L],f[][UL],l,r;
 inline void dfs1(int st,int pre,LL multi)
 {
     mul[++cnt]=multi;
     if(st==)return;
     for(RG int i=pre;i<;++i)
         if(multi*i<=r)dfs1(st+,i,multi*i);
 }
 inline int id(LL val){return lower_bound(mul+,mul+cnt+,val)-mul;}
 inline LL dfs(int st,int mul_id,bool limit)
 {
     if(mul[mul_id]>_9[st])return ;
     if(st==)return ;
     RG int i,lim=(limit?bin[st]:);
     LL ret=;
     for(i=;i<lim;++i)
         if(mul[mul_id]%i==)
             ret+=f[st-][id(mul[mul_id]/i)];
     if(lim&&bin[st])
         if(mul[mul_id]%bin[st]==)
             ret+=dfs(st-,id(mul[mul_id]/bin[st]),);
     return ret;
 }
 inline LL query(int id,LL n)
 {
     LL ret=;len=;
     while(n)bin[++len]=n%,n/=;
     for(RG int i=;i<len;++i)ret+=f[i][id];
     return ret+dfs(len,id,);
 }
 inline LL calc(LL n)
 {
     if(!n)return ;LL ret=;
     for(RG int i=;mul[i]<=n&&i<=cnt;++i)
         ret+=query(i,n/mul[i]);
     return ret;
 }
 int main()
 {
     RG int i,j,k;
     scanf("%lld%lld",&l,&r);
     mul[++cnt]=;
     dfs1(,,),sort(mul+,mul+cnt+),
     cnt=unique(mul+,mul+cnt+)-mul-;
     for(_9[]=i=;i<=;++i)_9[i]=_9[i-]*;
     for(f[][]=,i=;i<=;++i)f[][i]=;
     for(i=;i<=;++i)
         for(j=;j<=cnt;++j)if(f[i-][j])
             for(k=;k<=;++k)f[i][id(mul[j]*k)]+=f[i-][j];
     printf("%lld\n", calc(r) - calc(l-) );
 }

BZOJ1183+BZOJ2713

bzoj3530

　　不知道怎么混进来的AC自动机题目

　　前导0的处理需要注意，一开始没有想好

 #include <cstdio>
 #include <cstring>
 using namespace std;
 #define L 1510
 #define RG register
 #define mod 1000000007
 char s[L],str[L];
 bool ban[L];
 int n,cnt,ch[L][],fail[L],q[L],hd,tl,plan[L][L];
 inline int dfs(int rt,int left)
 {
     if(ban[rt])return plan[rt][left]=;
     if(plan[rt][left])return plan[rt][left];
     int ret=;
     for(RG int i=;i<;++i)
         if(!ban[ch[rt][i]])
             ret=(ret+dfs(ch[rt][i],left-))%mod;
     return plan[rt][left]=ret;
 }
 #define id(c) ((c)-'0')
 signed main()
 {
     RG int i,j,m,rt,l,d,ans=,good=;
     scanf("%s",s+),n=strlen(s+);
     scanf("%d",&m);
     cnt=;
     for(i=;i<=m;++i)
     {
         scanf("%s",str+),l=strlen(str+);
         for(rt=,j=;j<=l;++j)
         {
             d=str[j]-'';
             if(!ch[rt][d])ch[rt][d]=++cnt;
             rt=ch[rt][d];
             if(ban[rt])break;
         }
         ban[rt]=;
     }
     for(hd=,tl=,i=;i<;++i)
         if(ch[][i])q[++tl]=ch[][i],fail[ch[][i]]=;
         else ch[][i]=;
     while(hd<=tl)
         for(rt=q[hd++],i=;i<;++i)
             if(ch[rt][i])d=ch[rt][i],fail[d]=ch[fail[rt]][i],ban[d]|=ban[fail[d]],q[++tl]=d;
             else ch[rt][i]=ch[fail[rt]][i];
     for(i=;i<=cnt;++i)if(!ban[i])plan[i][]=;
     for(i=;i<=cnt;++i)if(!ban[i])
         for(j=;j<n;++j)if(!plan[i][j])dfs(i,j);
     for(i=;i<n;++i)for(j=;j<;++j)
         ans=(ans+plan[ch[][j]][i-])%mod;
     for(rt=,i=;i<=n;++i)
     {
         for(d=s[i]-'',j=(i==?:);j<d;++j)
             if(!ban[ch[rt][j]])ans=(ans+plan[ch[rt][j]][n-i])%mod;
         rt=ch[rt][d];
         if(ban[rt]){good=;break;}
     }
     printf("%d\n",ans+good);
 }

BZOJ3530

uoj86

题解在这里面，综合感不错的题目……

bzoj3652

相当于两部分分开求和再除总数然后加权

第二部分求异或和很好想，统计每位0/1个数然后搞就行

关于第一部分………在%wq的思路之后打过去了

第一部分相当于对于每一个数选一个数和它异或和最大

由于选的那个数也要在n的范围内，所以我们不太好搞

这样，我们正难则反，先认为每个数的每一位都能贡献上，再减去多余的贡献

由于n的二进制第一位一定是1，所以在2^(len-1)到n-1这些数一定每一位都能贡献上

那么我们一开始就拿着0~2^(len-1)-1这些数(len代表n的二进制长度)，维护剩下多少数

从n的高位往低位考虑，如果n的某一位是1，那么这一位如果填0的话，

现在这一位为1的数(正好占一半)就一定能贡献后面所有位的值(即他们一定不会超限，所以后面可以随意填)

那么我们把它们扔掉，即更改剩下数的多少

这个和一开始分析的最高位的情况类似

反之，如果为0，那么这一位为0的所有数(也是占一半)由于不能填1而无法贡献这一位的异或值

那么我们在答案中减去对应的值

 #include <cstdio>
 #include <cstring>
 #include <iostream>
 using namespace std;
 #define RG register
 #define LL long long
 #define db double
 LL bin[];
 int bit[],len;
 int main()
 {
     RG int i;LL n,m,tmp,cnt0,cnt1;
     db val1=,val2=,p,q;
     for(bin[]=i=;i<=;++i)bin[i]=bin[i-]<<;
     scanf("%lld%lf",&n,&p),m=n-;
     tmp=m;while(tmp)bit[++len]=tmp&,tmp>>=;
     for(i=len;~i;--i)
     {
         tmp=n>>(i+),cnt0=cnt1=tmp*bin[i];
         if(n&bin[i])cnt0+=bin[i],cnt1+=(bin[i]-)&n;
         else cnt0+=(bin[i]-)&n;
         val2+=2.0*cnt0*cnt1*bin[i];
     }
     val2/=n*1.0*n;
     val1=n*1.0*(bin[len]-);tmp=bin[len];
     for(i=len;i;--i)
         if(bit[i])tmp>>=;
         else val1-=(tmp>>)*1.0*bin[i-];
     printf("%.10lf\n",p*val1/n+(-p)*val2 );
 }

BZOJ3652

bzoj4513

感觉是上面一题的加强版

自己想的是dfs打法，但是由于情况太多无法手动分类讨论，打不出来

数组定义定义f[i][2][2][2]，后面三个0/1分别代表是否满足i<=n,j<=m,i^j>=k

现在我发现的AC写法(茴香豆的茴有四种写法你知道嘛)

1.(大部分网上题解使用的)4维数组dp

发现网上大部分人是用的迭代dp的打法

和我定义是一样的，可是……

代码实现出人意料的简洁

dp写法和dfs写法的确是各有所长

dp适合用很多for循环和边界特判无脑处理掉大量的分类讨论

而dfs适合无法很好用for循环枚举的东西

Ps:dp写法有一个地方不是太懂，就是为什么最后要把数组的每个元素都计算一遍

我们需要的答案难道不就是ans[1][1][1]吗

 #include <cstdio>
 #include <algorithm>
 #include <cstring>
 using namespace std;
 #define RG register
 #define LL long long
 LL n,m,k,bin[],f_ge[][][][],f_sum[][][][];
 int main()
 {
     RG int mod,i,ta,tb,tc,a,b,c,x,y,z,t,len,lena,lenb,lenc,bita,bitb,bitc;
     LL ans,tmp;scanf("%d",&t);
     while(t--)
     {
         scanf("%lld%lld%lld%d",&n,&m,&k,&mod),--n,--m;
         lena=lenb=lenc=;
         tmp=n;while(tmp)++lena,tmp>>=;
         tmp=m;while(tmp)++lenb,tmp>>=;
         tmp=k;while(tmp)++lenc,tmp>>=;
         len=max(lena,max(lenb,lenc));
         for(bin[]=i=;i<=len;++i)bin[i]=(bin[i-]<<)%mod;
         memset(f_ge,,sizeof(f_ge)),memset(f_sum,,sizeof(f_sum));
         f_ge[len+][][][]=;ans=;
         for(i=len;~i;--i)
         {
             bita=(n>>i)&,bitb=(m>>i)&,bitc=(k>>i)&;
             for(a=;a<;++a)for(b=;b<;++b)for(c=;c<;++c)
                 if(f_ge[i+][a][b][c])
                     for(x=;x<;++x)
                     {
                         if(a && x>bita)break;
                         for(y=;y<;++y)
                         {
                             if(b && y>bitb)break;
                             z=x^y;
                             if(c && z<bitc)continue;
                             ta=(a && bita==x)?:,tb=(b && bitb==y)?:,tc=(c && bitc==z)?:;
                             f_ge[i][ta][tb][tc]=(f_ge[i][ta][tb][tc]+f_ge[i+][a][b][c])%mod;
                             f_sum[i][ta][tb][tc]=( f_sum[i][ta][tb][tc]+f_sum[i+][a][b][c])%mod;
                             if(z)f_sum[i][ta][tb][tc]=( f_sum[i][ta][tb][tc]+ bin[i]*f_ge[i+][a][b][c]%mod )%mod;
                         }
                     }
         }
         k%=mod;
         for(a=;a<;++a)for(b=;b<;++b)for(c=;c<;++c)
             ans=(ans+f_sum[][a][b][c]-k*f_ge[][a][b][c]%mod+mod)%mod;
         printf("%lld\n",ans);
     }
 }

BZOJ4513

啊……我要再研究一下dfs写法，看看能不能打出来

upd：我完蛋了，我打不出来2333

2.wq式dp打法，强大又快速，wq Orzzzzzzzzzzzzzzzzzzzzzzzz

很巧妙，刷新了我对数位Dp的认识，让我理解更加深入了

让wq讲了一个多小时，感觉自己智商掉没了2333

但是还是不太懂，无法用语言描述……

等我更强了再来补这个做法……

bzoj3326

思路大概是很清真的，总的来说就是预处理前i位数的子串和，以及前缀子串之和，然后按照数位DP那样限制转移

但是……那个转移的式子……

啊真是让人痛苦，那个式子我总共大改了5遍才打过,并且有很多一开始没有注意到的细节

以后做题必须要先想好式子

每一项是什么为什么都要想清楚

要不特别耽误时间……有的时候船到桥头……就翻船了……

感觉思维严谨性得到了提高2333

 #include <cstdio>
 #include <cstring>
 using namespace std;
 #define RG register
 #define mod 20130427
 #define N 100010
 #define LL long long
 char cB[<<],*S=cB,*T=cB;
 #define getc (S==T&&(T=(S=cB)+fread(cB,1,1<<15,stdin),S==T)?0:*S++)
 inline int read()
 {
     RG int x=;RG char c=getc;
     while(c<''|c>'')c=getc;
     while(c>=''&c<='')x=*x+(c^),c=getc;
     return x;
 }
 inline int Sum(int a){return ((LL)a*(a+1ll)/)%mod;}
 inline int max(int a,int b){return a>b?a:b;}
 inline int min(int a,int b){return a<b?a:b;}
 int ge2[N],sum2[N],ge3[N],sum3[N],no_zero_sum3[N],B,lena,bit[N],lenb,bin[N];
 inline int calc(bool start,int left,int lim,int cnt,int sum,int sum_of_substring )
 {
     if(lim==)return ;
     if(start)
         return
             (
             (LL) Sum(lim-) * ge2[left] %mod * bin[left] %mod + //前与后连接之后前面的贡献
             (LL) ( lim -  ) %mod * sum3[left] %mod + no_zero_sum3[left] %mod +//后面的子串
             (LL) ( lim -  ) %mod * sum2[left] %mod//前与后连接之后后面的贡献
             )%mod;
     int new_sum=( (LL) sum * B %mod * lim %mod + (LL) Sum(lim-) * cnt %mod ) %mod;
     return
         (
         (LL) sum_of_substring * lim %mod * bin[left] %mod + //之前的子串
         (LL) new_sum * ge2[left] %mod * bin[left] %mod + //前与后连接之后前面的贡献
         (LL) lim %mod * sum3[left] %mod +//后面的子串 不乘cnt
         (LL) cnt * lim %mod * sum2[left] %mod//前与后连接之后后面的贡献 ,要乘cnt 因为再前面不同
         )%mod;
 }
 inline int dfs(bool start,int st,int cnt,int sum,int sum_of_substring)
 {
     if(st==)return ;
     int new_sum=( (LL) sum * B %mod + (LL) ( cnt +  ) * bit[st] %mod )%mod;
     return
         ( new_sum + calc(start, st- , bit[st] , cnt +  , sum , sum_of_substring ) +
         dfs(, st -  , cnt + ,  new_sum , (sum_of_substring + new_sum)%mod ) )%mod;
 }
 signed main()
 {
     RG int i,j,len,ans;
     B=read(),lena=read();
     for(i=lena;i;--i)bit[i]=read();
     lenb=read();len=max(lena,lenb);
     if(lena>||bit[]>)
     {
         --bit[],j=;
         while(bit[j]<)bit[j]+=B,--bit[j+],++j;
         while(lena>&&!bit[lena])--lena;
     }
     for(bin[]=ge2[]=i=;i<=len;++i)
     {
         bin[i]=(LL)bin[i-]*B%mod;
         ge2[i]=( ge2[i-] + bin[i] )%mod;
         ge3[i]=(LL) Sum(i) * bin[i] %mod;
         sum2[i]=( (LL) sum2[i-] * B %mod +  Sum ( bin[i] -  ) )%mod;
         sum3[i]=( (LL) Sum(B-) * bin[i-] %mod * ge2[i-] %mod + (LL)B * sum2[i-] %mod + (LL) B * sum3[i-] %mod )%mod;
         no_zero_sum3[i]=( (LL) Sum(B-) * bin[i-] %mod * ge2[i-] %mod +
                         (LL) (B - ) * sum2[i-] %mod + (LL) (B - ) * sum3[i-] %mod + no_zero_sum3[i-] )%mod;
     }
     ans=mod-dfs(,lena,,,);
     for(i=lenb;i;--i)bit[i]=read();
     printf("%d\n",(ans+dfs(,lenb,,,))%mod);
 }

bzoj3326

其实还有另外一种思路，那就是反过来从前往后走，并且用矩阵乘优化

这个是wq的原创思路……

bzoj3598

　　没做呢，听说挺简单，但是我没想出来

　　这次时间不够了……不想怂题解

　　有时间再做……

这次做的题就是这么多……接下来要去找“有思维难度的DP题”了……加油咯……