数位dp：处理数字数位关系的一种dp方式。

一般的题目特征十分明显：

1.一般和数字本身有很大关系。

2.一般求数字在区间L，R中的一些信息

3.L，R一般很大，通常能达到long long级别。

dp方式也比较有套路：

一般有三种方法：

本质上的相似之处，都是集中在处理“填数有无限制”，“填数无限制情况下的固定方案数”，“某些已经搜出来的固定方案数”

1.记忆化搜索（没用过）

是一种倒着记忆的方法。

2.递推（我基本都是这个方法）

正着递推出答案。

一般会从高位向低位递推，讨论高位的填数方法，从而递推出低位的限制与否。

从高位到低位可以通过填的位数处理限制问题。

用一个[0/1]表示，填完这一位之后，是否对后面的数有限制。

填一个数，从k<num,k==num,k>num 讨论。

注意处理可能出现的前导零的锅。

3.预处理一些固定没有限制的一些位置，然后从高位开始填，

没有限制的话，直接查表。

有限制的话，继续填下一位。

注意处理已经填好的位置的固定影响。

经典入门例题：

[ZJOI2010]数字计数

给定两个正整数a和b，求在[a,b]中的所有整数中，每个数码(digit)各出现了多少次。

直接做就好了。

可以处理1~9，1~99，。。的固定答案，或者直接递推下去。

处理1~9,1~99，1~999...的方法：

Code：

  1. #include<bits/stdc++.h>
  2. #define ll long long
  3. using namespace std;
  4. const int N=;
  5. ll a,b;
  6. ll cnta[],cntb[];
  7. ll f[],ten[];
  8. void query(ll x,ll *cnt)
  9. {
  10.     int len=;
  11.     int num[];
  12.     ll k=x;
  13.     while(k)
  14.     {
  15.         num[++len]=k%;
  16.         k/=;
  17.     }
  18.     for(int i=len;i>=;i--)
  19.     {
  20.         for(int j=;j<=;j++)
  21.          cnt[j]=cnt[j]+f[i-]*num[i];
  22.         for(int j=;j<num[i];j++)
  23.          cnt[j]+=ten[i-];
  24.         ll num2=;
  25.         for(int j=i-;j>=;j--)
  26.         {
  27.             num2=num2*+num[j];
  28.         }
  29.         num2++;
  30.         cnt[num[i]]+=num2;
  31.         cnt[]-=ten[i-];
  32.     }
  33. }
  34. int main()
  35. {
  36.     scanf("%lld%lld",&a,&b);
  37.     ten[]=;
  38.     for(int i=;i<=;i++)
  39.     {
  40.         f[i]=f[i-]*+ten[i-];
  41.         ten[i]=ten[i-]*;
  42.     }
  43.     query(a-,cnta);
  44.     query(b,cntb);
  45.     for(int i=;i<=;i++)
  46.      printf("%lld ",cntb[i]-cnta[i]);
  47.     return ;
  48. }

数字计数1

递推处理:

Code:

  1. #include<bits/stdc++.h>
  2. using namespace std;
  3. typedef long long ll;
  4. const int N=;
  5. struct node{
  6.     ll a[];
  7.     void init(){
  8.         memset(a,,sizeof a);
  9.     }
  10.     node operator +(const node &b){
  11.         node c;c.init();
  12.         for(int i=;i<=;i++)
  13.            c.a[i]=a[i]+b.a[i];
  14.         return c;
  15.     }
  16.     node operator *(const int &x){
  17.         node c;c.init();
  18.         for(int i=;i<=;i++)
  19.          c.a[i]=a[i]*x;
  20.         return c;
  21.     }
  22.     node operator -(const node &b){
  23.         node c;c.init();
  24.         for(int i=;i<=;i++)
  25.            c.a[i]=a[i]-b.a[i];
  26.         return c;
  27.     }
  28.     void op(){
  29.         cout<<endl;
  30.         for(int i=;i<=;i++)
  31.          cout<<" "<<a[i];cout<<endl;cout<<endl;
  32.     }
  33. }f[N][],ans,kk;
  34. int num[N],cnt;
  35. ll ten[N];
  36. ll pre[N];
  37. ll A,B;
  38. void sol(){
  39.     for(int i=;i<=cnt+;i++)
  40.      for(int j=;j<=;j++)
  41.       f[i][j].init();
  42.     for(int i=cnt;i>=;i--){
  43.         //cout<<num[i]<<" dig"<<endl;
  44.         f[i][]=f[i+][];f[i][].a[num[i]]++;
  45.         f[i][]=(f[i+][]*num[i])+(f[i+][]*);
  46.         for(int j=;j<=;j++)
  47.         {
  48.             if(j<num[i]) f[i][].a[j]+=(pre[i+]+);
  49.             else f[i][].a[j]+=pre[i+];
  50.         }
  51.         //f[i][1].op();
  52.         //f[i][0].op();
  53.     }
  54.     for(int i=cnt;i>=;i--){
  55.         f[][].a[]-=ten[i-];
  56.     }
  57. }
  58. int main()
  59. {
  60.     scanf("%lld%lld",&A,&B);ten[]=;
  61.     for(int i=;i<=;i++)ten[i]=ten[i-]*(ll);
  62.     while(B){
  63.         num[++cnt]=B%;
  64.         pre[cnt]=B;B/=;
  65.     }
  66.     //pre[cnt+1]=1;
  67.     sol();
  68.     ans=ans+f[][]+f[][];
  69.  
  70.     cnt=;memset(num,,sizeof num);
  71.     memset(pre,,sizeof pre);
  72.     A--;
  73.     while(A){
  74.         num[++cnt]=A%;
  75.         pre[cnt]=A;
  76.         A/=;
  77.     }
  78.     //pre[cnt+1]=1;
  79.  
  80.     sol();
  81.     kk=kk+f[][]+f[][];
  82.     ans=ans-kk;
  83.  
  84.     for(int i=;i<=;i++){
  85.         printf("%lld ",ans.a[i]);
  86.     }
  87.     return ;
  88. }

数字计数2

[SCOI2009]windy数

windy定义了一种windy数。不含前导零且相邻两个数字之差至少为2的正整数被称为windy数。 windy想知道，

在A和B之间，包括A和B，总共有多少个windy数？

Solution：

直接记录最后一个数是什么，要记录是否已经出现了非零数字，即前导零。处理前导零bug

因为前导零不处理，可能会认为最后一位填的是0，从而不能填1、0了。

f[i][last][0/1限制][0/1有无出现非零数字]

Code:

  1. #include<bits/stdc++.h>
  2. using namespace std;
  3. const int N=;
  4. int f[N][N][][];
  5. int num[N],cnt;
  6. int A,B;
  7. int wrk(){
  8.     memset(f,,sizeof f);
  9.     for(int i=;i<num[cnt];i++) f[cnt][i][][]=;
  10.     f[cnt][num[cnt]][][]=;
  11.     f[cnt][][][]=;
  12.  
  13.     for(int i=cnt;i>=;i--){
  14.         for(int j=;j<=;j++){
  15.             for(int k=;k<=;k++){
  16.                 if(abs(k-j)>=){
  17.                     if(j==num[i]&&k==num[i-]) f[i-][k][][]+=f[i][j][][];
  18.                     if(j==num[i]&&k<num[i-]) f[i-][k][][]+=f[i][j][][];
  19.                     f[i-][k][][]+=f[i][j][][];
  20.                     if(j==) f[i-][k][][]+=f[i][j][][];
  21.                 }
  22.             }
  23.         }
  24.         f[i-][][][]+=f[i][][][];
  25.         f[i-][][][]+=f[i][][][];
  26.     }
  27.     int ret=;
  28.     for(int j=;j<=;j++){
  29.         ret+=f[][j][][]+f[][j][][];
  30.     }
  31.     //ret+=f[1][0][0][0];
  32.     return ret;
  33. }
  34. int main()
  35. {
  36.     scanf("%d%d",&A,&B);
  37.     while(B){
  38.         num[++cnt]=B%;B/=;
  39.     }
  40.     int ansB=wrk();
  41.  
  42.     A--;cnt=;
  43.     while(A){
  44.         num[++cnt]=A%;A/=;
  45.     }
  46.     int ansA=wrk();
  47.  
  48.     //cout<<ansB<<" "<<ansA<<endl;
  49.  
  50.     printf("%d",ansB-ansA);
  51.     return ;
  52. }

windy数

SAC#1 - 萌数

辣鸡蒟蒻SOL是一个傻逼，他居然觉得数很萌！

好在在他眼里，并不是所有数都是萌的。只有满足“存在长度至少为2的回文子串”的数是萌的——也就是说，101是萌的，因为101本身就是一个回文数；110是萌的，因为包含回文子串11；但是102不是萌的，1201也不是萌的。

现在SOL想知道从l到r的所有整数中有多少个萌数。

由于答案可能很大，所以只需要输出答案对1000000007（10^9+7）的余数。

Solution：

抓住问题本质，长度至少为2的回文子串，只要有2或者3就一定满足。

所以，只要记录上一位，上上位填的数即可。

还要记录是否已经出现过长度为2或者3的回文串。

同样，前导零的锅也要处理的。

Code：

  1. #include<bits/stdc++.h>
  2. using namespace std;
  3. typedef long long ll;
  4. const int N=+;
  5. const int mod=1e9+;
  6. int n,m;
  7. char a[N],b[N];
  8. int la,lb;
  9. ll ans;
  10. ll r,l;
  11. ll f[N][][][][][];// lim ; has huiwen ; has >=1
  12. ll wrk(char *s,int len){
  13.     memset(f,,sizeof f);
  14.     for(int j=;j<=s[]-'';j++){
  15.         if(j!=){
  16.             if(j<s[]-'')f[][][][][j][]=;
  17.             else f[][][][][j][]=;
  18.         }
  19.         else f[][][][][][]=;
  20.     }
  21.     if(len==) return ;
  22.     for(int i=;i<=lb;i++){
  23.         for(int j=;j<=;j++){
  24.             for(int k=;k<=;k++){
  25.                 for(int p=;p<=;p++){
  26.                     if(p<s[i]-''){
  27.  
  28.                         if(p==k||p==j) (f[i][][][k][p][]+=f[i-][][][j][k][]+f[i-][][][j][k][])%=mod;
  29.                         else (f[i][][][k][p][]+=f[i-][][][j][k][]+f[i-][][][j][k][])%=mod;
  30.                         (f[i][][][k][p][]+=f[i-][][][j][k][]+f[i-][][][j][k][])%=mod;
  31.                     }
  32.                     else if(p==s[i]-''){
  33.                         if(p==k||p==j) (f[i][][][k][p][]+=f[i-][][][j][k][])%=mod;
  34.                         else (f[i][][][k][p][]+=f[i-][][][j][k][])%=mod;
  35.                         (f[i][][][k][p][]+=f[i-][][][j][k][])%=mod;
  36.  
  37.                         if(p==k||p==j) (f[i][][][k][p][]+=f[i-][][][j][k][])%=mod;
  38.                         else (f[i][][][k][p][]+=f[i-][][][j][k][])%=mod;
  39.                         (f[i][][][k][p][]+=f[i-][][][j][k][])%=mod;
  40.                     }
  41.                     else{
  42.                         if(p==k||p==j) (f[i][][][k][p][]+=f[i-][][][j][k][])%=mod;
  43.                         else (f[i][][][k][p][]+=f[i-][][][j][k][])%=mod;
  44.                         (f[i][][][k][p][]+=f[i-][][][j][k][])%=mod;
  45.                     }
  46.                 }
  47.             }
  48.         }
  49.         for(int p=;p<=;p++){
  50.             if(p==) (f[i][][][][p][]+=f[i-][][][][][])%=mod;
  51.             else (f[i][][][][p][]+=f[i-][][][][][])%=mod;
  52.         }
  53.     }
  54.     ll ret=;
  55.     for(int j=;j<=;j++)
  56.      for(int k=;k<=;k++){
  57.          (ret+=f[len][][][j][k][]+f[len][][][j][k][])%=mod;
  58.      }
  59.     return ret;
  60. }
  61. int main()
  62. {
  63.     scanf("%s",a+);scanf("%s",b+);
  64.     la=strlen(a+),lb=strlen(b+);
  65.  
  66.     l=wrk(a,la);
  67.     r=wrk(b,lb);
  68.  
  69.     bool fl=false;
  70.     for(int i=;i<=la;i++){
  71.         if(a[i]==a[i-]||a[i]==a[i-]) fl=true;
  72.     }
  73.     ans=(r+fl-l+mod)%mod;
  74.     printf("%lld",ans);
  75.     return ;
  76. }

萌数

bzoj 3329 Xorequ

Description

Input

第一行一个正整数，表示数据组数据 ，接下来T行
每行一个正整数N

Output

2*T行
第2*i-1行表示第i个数据中问题一的解，

第2*i行表示第i个数据中问题二的解，

HINT

x=1与x=2都是原方程的根，注意第一个问题的解

不要mod 10^9+7

1<=N<=10^18

1<=T<=1000

Solution：

首先一定要化简x^3x=2x

即：3x=x^2x ; x+2x=x^2x 说明，2倍的x和x没有公共1位置，否则就会变小了。

2x就是x二进制下左移一位，所以，x的条件其实是，x的二进制表示下没有连续的两个1.

对于第一问，记录上一位填的是0/1即可转移。

对于第二问，发现，是2的整次幂。2^n显然满足条件，

这里假设可以是0，不需要正整数条件，而0显然也满足条件。

最后也不用减，因为2^n本来就要加1个。

即处理有n位可以填0/1。

设f[i]表示，i位随便填0/1，符合的数的个数。

第i位填1的话，i-1位只能填零，方案数就是f[i-2]

第i位填0的话，对i-1位没有影响，就是f[i-1]

所以f[i]=f[i-1]+f[i-2],f[1]=2，f[2]=3

一个斐波那契数列。

矩阵乘法优化一下即可。

Code:（多组数据记得memset）

  1. #include<bits/stdc++.h>
  2. using namespace std;
  3. typedef long long ll;
  4. const int N=;
  5. const int mod=1e9+;
  6. ll f[N][][];
  7. int num[N],cnt;
  8. ll wrk1(){
  9.     memset(f,,sizeof f);
  10.     f[cnt+][][]=;
  11.     for(int i=cnt;i>=;i--){
  12.         for(int k=;k<=;k++){
  13.             if(k<num[i]){
  14.                 if(k==) f[i][][k]+=f[i+][][]+f[i+][][];
  15.                 else f[i][][k]+=f[i+][][]+f[i+][][]+f[i+][][]+f[i+][][];
  16.             }
  17.             else if(k==num[i]){
  18.                 if(k==) f[i][][k]+=f[i+][][],f[i][][k]+=f[i+][][];
  19.                 else f[i][][k]+=f[i+][][]+f[i+][][],f[i][][k]+=f[i+][][]+f[i+][][];
  20.             }
  21.             else {
  22.                 if(k==) f[i][][k]+=f[i+][][];
  23.                 else f[i][][k]+=f[i+][][]+f[i+][][];
  24.             }
  25.         }
  26.     }
  27.     ll ret=;
  28.     ret=f[][][]+f[][][]+f[][][]+f[][][];
  29.     return ret-;
  30. }
  31. struct tr{
  32.     ll a[][];
  33.     void pre(){
  34.         memset(a,,sizeof a);
  35.     }
  36.     void init(){
  37.         for(int i=;i<=;i++) a[i][i]=;
  38.     }
  39.     tr operator *(const tr &b){
  40.         tr c;c.pre();
  41.         for(int i=;i<=;i++)
  42.           for(int k=;k<=;k++)
  43.             for(int j=;j<=;j++){
  44.                 (c.a[i][j]+=a[i][k]*b.a[k][j]%mod)%=mod;
  45.             }
  46.         return c;
  47.     }
  48. }A,S,B;
  49. tr qm(tr x,ll y){
  50.     tr ret;ret.pre();ret.init();
  51.     while(y){
  52.         if(y&) ret=ret*x;
  53.         x=x*x;
  54.         y>>=;
  55.     }
  56.     return ret;
  57. }
  58. int t;
  59. ll n;
  60. int main()
  61. {
  62.     scanf("%d",&t);
  63.     A.a[][]=,A.a[][]=;
  64.     B.a[][]=,B.a[][]=;
  65.     B.a[][]=,B.a[][]=;
  66.  
  67.     while(t--){
  68.         scanf("%lld",&n);
  69.         ll nn=n;
  70.         cnt=;
  71.         while(nn){
  72.             num[++cnt]=nn%;nn/=;
  73.         }
  74.         ll ans1=wrk1();
  75.         printf("%lld\n",ans1);
  76.  
  77.         ll ans2;
  78.         if(n==){
  79.             ans2=;
  80.         }
  81.         else if(n==){
  82.             ans2=;
  83.         }
  84.         else{
  85.             S=A*qm(B,n-);
  86.             ans2=S.a[][]%mod;
  87.         }
  88.         printf("%lld\n",ans2);
  89.     }
  90.     return ;
  91. }

Xorequ

CF55D Beautiful numbers

Volodya是一个很皮的男孩。他认为一个能被它自己的每一位数上的数整除（非0）的数是很妙的。我们先忽略他的想法的正确性，只回答在l到r之间有多少个很妙的数字。

输入输出格式

输入：总共有t个询问：

第一行：t；

接下来t行：每行两个数l和r。

注意：请勿使用%lld读写长整型（虽然我也不知道为什么），请优先使用cin（或者是%I64d）。

输出：t行，每行为一个询问的答案。

Solution：

比较巧妙的状态设计，还有优化 的题目。

直接记录被1,2,3..除是肯定不行的，。

发现，lcm（1,2.。。9）=2520

所以，如果最后能被1，2.。。9整除，那么把这个数对2520取模，不会影响整除与否的。

所以，f[i][2520][S]表示，填到i位，对2520取模结果，出现数字的状压集合。

但是，这个题有10组数据，就T飞了。

考虑优化没用的状态。

S大小是256的，不用记0，不用记1，要记8个。

但是，最后要找的还是S出现数字的lcm能否整除x

所以，就直接记录lcm就行了。

2250=2^3*3^2*5*7，一共只有48种lcm，离散化记录，256->48

但是还是过不去（可能我的代码常数太大？）

发现，记录mod 2250的余数时，假设之前是j，

那么，新的=j*10+k mod 2250（k是当前位的数）

设x=a2250+j;

每次j要乘10，是不是记录mod 225即可？

x=a'225 + j'

x'=a'2250+10j'+k

发现，x mod 2250 的只和j‘有关，

所以，记录j'即可，每次mod 225记录新的j

最后一次，mod 2250 就是mod 2250 的余数了。

Code：（luogu最优解）

  1. #include<bits/stdc++.h>
  2. using namespace std;
  3. typedef long long ll;
  4. const int N=;
  5. const int up=;
  6. ll L,R;
  7. int a[N],cnt;
  8. ll f[N][][][];
  9. ll g[][][];
  10. int lcm[],tot;
  11. int id[];
  12. int to[][];
  13. int gcd(int p,int q){
  14.     return q?gcd(q,p%q):p;
  15. }
  16. void dfs(int x,int lc){
  17.     //cout<<" x lc "<<x<<" "<<lc<<endl;
  18.     if(x==){
  19.         lcm[++tot]=lc;
  20.         return;
  21.     }
  22.     dfs(x+,lc);
  23.     dfs(x+,lc*x/gcd(x,lc));
  24. }
  25. ll wrk(){
  26.     ll ret=;
  27.     memset(f,,sizeof f);
  28.     memset(g,,sizeof g);
  29.     f[cnt+][][][]=;
  30.     for(int i=cnt;i>=;i--){
  31.         for(int j=;j<;j++){
  32.             for(int k=;k<=tot;k++){
  33.                 for(int p=;p<=;p++){
  34.                     if(i!=){
  35.                         if(p<a[i]){
  36.                             f[i][(j*+p)%up][][to[k][p]]+=f[i+][j][][k]+f[i+][j][][k];
  37.  
  38.                         }
  39.                         else if(p==a[i]){
  40.                             f[i][(j*+p)%up][][to[k][p]]+=f[i+][j][][k];
  41.                             f[i][(j*+p)%up][][to[k][p]]+=f[i+][j][][k];
  42.                         }
  43.                         else {
  44.                             f[i][(j*+p)%up][][to[k][p]]+=f[i+][j][][k];
  45.                         }
  46.                     }
  47.                     else{
  48.                         if(p<a[i]){
  49.                             g[(j*+p)%][][to[k][p]]+=f[i+][j][][k]+f[i+][j][][k];
  50.  
  51.                         }
  52.                         else if(p==a[i]){
  53.                             g[(j*+p)%][][to[k][p]]+=f[i+][j][][k];
  54.                             g[(j*+p)%][][to[k][p]]+=f[i+][j][][k];
  55.                         }
  56.                         else {
  57.                             g[(j*+p)%][][to[k][p]]+=f[i+][j][][k];
  58.                         }
  59.                     }
  60.                 }
  61.             }
  62.         }
  63.     }
  64.     for(int j=;j<;j++){
  65.         for(int k=;k<=tot;k++){
  66.             if(j%lcm[k]==){
  67.                 ret+=g[j][][k]+g[j][][k];
  68.             }
  69.         }
  70.     }
  71.  
  72.     return ret;
  73. }
  74. int T;
  75. ll ansl,ansr;
  76. int main()
  77. {
  78.     dfs(,);
  79.     sort(lcm+,lcm+tot+);
  80.     //cout<<tot<<endl;
  81.     tot=unique(lcm+,lcm+tot+)-lcm-;
  82.     for(int i=;i<=tot;i++) id[lcm[i]]=i;
  83.     for(int i=;i<=tot;i++){
  84.         to[i][]=i;
  85.         for(int j=;j<=;j++){
  86.             to[i][j]=id[lcm[i]*j/gcd(lcm[i],j)];
  87.         }
  88.     }
  89.  
  90.     /*cout<<" tot "<<tot<<endl;
  91.     for(int i=1;i<=tot;i++){
  92.         cout<<lcm[i]<<" "<<id[lcm[i]]<<" "<<endl;
  93.         for(int j=0;j<=9;j++){
  94.             cout<<" with "<<j<<" : "<<to[i][j]<<endl;
  95.         }
  96.     }*/
  97.  
  98.     scanf("%d",&T);
  99.     while(T--){
  100.         scanf("%I64d%I64d",&L,&R);
  101.         ansl=ansr=;
  102.         L--;
  103.  
  104.         if(L==) ansl=;
  105.         else{cnt=;
  106.             while(L){
  107.                 a[++cnt]=L%;L/=;
  108.             }ansl=wrk();
  109.         }
  110.  
  111.         cnt=;
  112.         while(R){
  113.             a[++cnt]=R%;R/=;
  114.         }ansr=wrk();
  115.  
  116.         printf("%I64d\n",ansr-ansl);
  117.     }
  118.     return ;
  119. }

Beautiful numbers

[CQOI2016]手机号码

比较麻烦的数位dp

见另一片博客：

[CQOI2016]手机号码

[SCOI2014]方伯伯的商场之旅

非常麻烦的数位dp了。

见另外一篇博客：

[SCOI2014]方伯伯的商场之旅

数位dp——奏响数字数位的美妙乐章的更多相关文章

  1. 【数位DP】数字统计

    题目 给定两个正整数a和b,求在[a,b]中的所有整数中,每个数码(digit)各出现了多少次. 数位DP (1)分情况,逐位讨论. (2)模型:计算在[L,R]中有多少个数满足条件. (3)套路:将 ...

  2. 洛谷 - P2602 - 数字计数 - 数位dp

    https://www.luogu.org/problemnew/show/P2602 第二道数位dp,因为“数位dp都是模板题”(误),所以是从第一道的基础上面改的. 核心思想就是分类讨论,分不同情 ...

  3. 【学习笔记&训练记录】数位DP

    数位DP,即对数位进行拆分,利用数位来转移的一种DP,一般采用记忆化搜索,或者是先预处理再进行转移 一个比较大略的思想就是可以对于给定的大数,进行按数位进行固定来转移记录答案 区间类型的,可以考虑前缀 ...

  4. Codeforces Round #235 (Div. 2) D. Roman and Numbers （数位dp、状态压缩）

    D. Roman and Numbers time limit per test 4 seconds memory limit per test 512 megabytes input standar ...

  5. 数位dp 的简单入门

    时间紧张,就不讲那么详细了. 之前一直被深搜代码误解,以为数位dp 其实就是记忆化深搜...(虽说爆搜确实很舒服而且还好想) 但是后来发现数位dp 的标准格式其实是 预处理 + dp ...... 数 ...

  6. hdu6148 百度之星程序设计竞赛复赛 （数位dp）

    Valley Numer Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Tota ...

  7. 递推、数位DP解析（以HDU 2089 和 HDU 3555 为例）

    HDU 2089 不要62 题目链接 http://acm.hdu.edu.cn/showproblem.php?pid=2089 Problem Description 杭州人称那些傻乎乎粘嗒嗒的人 ...

  8. 【hdu4507】吉哥系列故事——恨7不成妻 数位dp

    题目描述 求 $[L,R]$ 内满足:数位中不包含7.数位之和不是7的倍数.本身不是7的倍数 的所有数的平方和 mod $10^9+7$ . 输入 输入数据的第一行是case数T(1 <= T ...

  9. [hdu 2089] 不要62 数位dp|dfs 入门

    题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=2089 题意:求[n, m]区间内不含4和62的数字个数. 这题有两种思路,直接数位dp和dfs 数位d ...

随机推荐

  1. Wild Dog sample [sync data]

    <html> <head> <meta charset="UTF-8"> <title>test wilddog </titl ...

  2. 20155217《网络对抗》Exp03 免杀原理与实践

    20155217<网络对抗>Exp03 免杀原理与实践 实践内容 正确使用msf编码器,msfvenom生成如jar之类的其他文件,veil-evasion,自己利用shellcode编程 ...

  3. 利用git将项目上传到github

            本文主要介绍如果用git将项目上传到githup. 一.准备工作         (1)欲将项目上传到githup,先在githup上新建一个仓库.这里就不介绍.         (2 ...

  4. effective c++ 笔记 (35-40)

    //---------------------------15/04/24---------------------------- //#35   考虑virtual函数以外的其他选择 { /* 1: ...

  5. Yeoman的好基友：Grunt

    grunt介绍 前端不能承受之痛 1.这是我们的生活 文件压缩:YUI Compressor.Google Closure 文件合并:fiddler + qzmin 文件校验:jshint 雪碧图:c ...

  6. centos7 源码部署LNMP

    一.环境 系统环境:centos 7.4 64位 Nginx:1.7.9 MySQL: 5.7.20 (二进制包) PHP:5.6.37 二.Ngin 安装 Nginx部署 yum install   ...

  7. GitHub 新手教程 三，Git Bash

    1,通过 开始菜单 启动 Git Bash,或者 在 cmd 下执行以下命令: D:\SoftWare\Git\git-bash.exe --cd-to-home (D:\SoftWare\Git 是 ...

  8. 教你用PS制作雨天窗户上透明水滴字

    雨天窗户上透明水滴字制作方法很简单,主要利用图层样式来实现.学习后可以让你对图层样式有更好的了解,认识. 先看下完成后的效果图: 步骤1: 在Photoshop中我们新建或Ctrl+N,创建1920x ...

  9. PAT甲题题解-1127. ZigZagging on a Tree (30)-中序、后序建树

    根据中序遍历和前序遍历确定一棵二叉树,然后按“层次遍历”序列输出.输出规则:除根节点外,接下来每层的节点输出顺序是:先从左到右,再从右到左,交替输出 #include <iostream> ...

  10. Linux内核分析——第六周学习笔记

    进程的描述和进程的创建 前言:以下笔记除了一些讲解视频中的概念记录,图示.图示中的补充文字.总结.分析.小结部分均是个人理解.如有错误观点,请多指教! PS.实验操作会在提交到MOOC网站的博客中写.