数位dp作业

dp东西实在太多，昨天开了个树形dp入门，还没入呢，今天就要写数位dp，也不知道这种学习状态对不对啊？

A - 不要62

题意：

输入n到m内，符合条件的数的个数。条件：不含62和4。

这里直接学习qkoqhh大佬的思路。

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<iostream>
 #include<queue>
 #include<cmath>
 #define inc(i,l,r) for(int i=l;i<=r;i++)
 #define dec(i,l,r) for(int i=l;i>=r;i--)
 #define link(x) for(edge *j=h[x];j;j=j->next)
 #define eps 1e-8
 #define inf 1000000007
 #define mem(a) memset(a,0,sizeof(a))
 #define ll long long
 #define succ(x) (1<<x)
 #define lowbit(x) (x&(-x))
 #define sqr(x) ((x)*(x))
 #define mid (x+y>>1)
 #define NM 305
 #define nm 1000005
 #define pi 3.141592653
 using namespace std;
 int read(){
     int x=,f=;char ch=getchar();
     while(!isdigit(ch)){if(ch=='-')f=-;ch=getchar();}
     while(isdigit(ch))x=x*+ch-'',ch=getchar();
     return f*x;
 }
 int d[][],_x,n,b[];
 //f:高位与原位是否相同
 int dfs(int n,bool f,int t){
     if(!n)return ;
     if(!f&&d[n][t])return d[n][t];
     int ans=,m=f?b[n]:;
     for(int i=;i<=m;i++)
         if(i!=&&!(t==&&i==)){
             ans+=dfs(n-,f&&i==m,i);
             //printf("%d %d:%d\n",n,i,ans);
         }
     return d[n][t]=ans;
 }
 int solve(int x){
     mem(b);mem(d);
     for(n=;x;x/=)b[++n]=x%;
     return dfs(n,true,);
 }
 int main(){
     while(_x=read())printf("%d\n",solve(read())-solve(_x-));
     return ;
 }

下面贴上我学习这份优秀代码的一点注释

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 using namespace std;
 int bit[], d[][];
 int dfs(int pos, bool flag, int t){
 /*
  * pos:当前位的位置;
  * flag:高位与原位相同(true)
  * t:高位，即当前位的前一位
 */
     if(!pos)    return ;
     if(!flag&&d[pos][t])    return d[pos][t];
     //高位与原位不同， 直接返回，不用考虑当前位与原位大小
     int ans = , m = flag?bit[pos]:;
     for(int i=;i<=m;i++){
         if(i!= && !(i==&&t==)){
             ans+=dfs(pos-, flag&&i==m, i);
             //这里第二个参数可依据flag的定义理解
             //同样这里比较灵活，有时需要分类讨论
         }
     }
     return d[pos][t]=ans;
 }
 int solve(int x){
     memset(bit, , sizeof(bit));
     memset(d, , sizeof(d));
     int len = ;
     while(x){
         bit[++len] = x%;
         x /= ;
     }
     return dfs(len, true, );
 }
 int main(){
     int n, m;
     while( scanf("%d%d", &n, &m)!=EOF && n && m){
         printf("%d\n", solve(m)-solve(n-));
     }
     return ;
 }

B - B-number

题意： 统计1到n中有13且能被13整除的数。

这是我写的第二道数位dp题，目前对我来说，数位dp题的难点在于状态的转移 和 合理正确的统计(这个比较灵活)。

拿到这道题，思考后对比上题的模板，需要新增参数判断高位前是否出现了13，以及如何处理能被13整除。这里余数的处理用到了 同余定理乘法以及加法的运用，这个技巧我不熟练（不知道），这里余数的参数传递就有难度了。

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 using namespace std;
 int bit[], d[][][][], c[];
 bool vis[][][][];
 int dfs(int pos, bool flag, bool is13, int t, int mod){
 /*
  * pos:当前位的位置;
  * flag:高位与原位相同(true)
  * is13:高位前是否出现13
  * t:高位，即当前位的前一位
  * mod:当前数/13的余数
 */
     if(!pos){
         if(is13 && !mod) return ;  //出现13,且mod为0,可以整除
         else    return ;
     }
     if(!flag&&vis[pos][t][mod][is13])    return d[pos][t][mod][is13];
     int ans = , m = flag?bit[pos]:;
     for(int i=;i<=m;i++){
         if((t== && i==) || is13){
             /*
              *int chushu = (mod*10 + i)%13;
              *这里不能这样算，有种自己在胡搞的感觉
              *
              * 这里是同余定理加法和乘法的应用，其实不用深究，写个例子就明白了
              * 可以这样理解 ：
              * x%13=(c[i]*10^i + c[j]*10^j + ……)%13 = (mod + c[j]*10^j + ……)%13
              * 拆开后就好
              * 这里可以预处理c[]
              * 传递时仔细对待mod
             */
             int chushu = (mod + c[pos]*i)%;
             ans += dfs(pos-, flag&&i==m, true, i, chushu);
         }else{
             int chushu = (mod + c[pos]*i)%;
             ans += dfs(pos-, flag&&i==m, false, i, chushu);
         }
     }
     vis[pos][t][mod][is13]=true;
     return d[pos][t][mod][is13]=ans;
 }
 int solve(int x){
     memset(bit, , sizeof(bit));
     memset(d, , sizeof(d));
     memset(vis, , sizeof(vis));
     int len = ;
     while(x){
         bit[++len] = x%;
         x /= ;
     }
     return dfs(len, true, false, , );
 }
 int main(){
     int n;
     c[] = ;
     for(int i=; i<=; i++) c[i]=c[i-]*%;
     while( scanf("%d", &n)!=EOF && n ){
         printf("%d\n", solve(n));
     }
     return ;
 }

C - Balance Number

题意：

定义一种平衡数：在pivot两边的数与pivot的torques之和相等，统计[x,y]内bn的个数。

这里记录下做这题的思路（虽然这题写出来没过样例，但感觉自己思路还说的过去）:

先思考状态转移所需要的参数，即维度：除前面模板里套路的pos和flag外，还需要pivot的位置，还需要计算和比较pivot两边的torques之和是否相等。

前三个维度各设一个参数，最后的比较可以设置为一个torqueses，对左右扭矩求向量和，若符合条件，则最终和为0(这里我没想到)。

下来就是上面那个模板的套路去写。有几个需要注意的细节(其实都是我开始没想到的，对大佬来说这些很显然的东西，对我就从没显然过)：

1. 若扭矩和<0，直接返回，这里相当于利用一个剪枝，难思考但是不难理解。
2. 就是在0的情况下，这种数无论pivot在哪都符合条件所以多级算了(len-1)次。dfs()搜索是0的情况是len位全0。
3. 就是这道题有个记忆化搜索的如何记忆化的问题。什么时候更新dp，时间上还是有差距的，下面的代码在这点上与上面的模板不同。

 #include <cstdio>
 #include <algorithm>
 #include <cstring>
 using namespace std;
 #define LL long long
 const int INF = 0x3f3f3f3f;
 LL dp[][][];
 int bit[];
 /*
  * pos:当前位位置
  * pivot: 题中所描述的balanced number的"中间"的那个点
  * torques:这里判断pivot左右扭矩之和是否相等可以用求其和torques看是否等于0
  *          这里最开始我的想法是用两个参数，扫描到pos=0时判断其是否相等，这样就烦琐了
  * flag:同理前面的模板
 */
 LL dfs(int pos, int pivot, int torques, bool flag){
     if(!pos)    return torques==;
     //若枚举结束，扭矩和为0，则说明pivot这点可以使这个数成为balance number
     if(torques < )    return ;
     //这里如果没有搜索完，扭矩和就小于0,则这个数一定不会是b n，这个判断很巧妙，这个有了方向后计算很方便
     if(!flag && dp[pos][pivot][torques]!=-) return dp[pos][pivot][torques];
     LL ans = ;
     LL m = flag?bit[pos]:;
     for(int i=; i<=m; i++){
         ans += dfs(pos-, pivot, torques+i*(pos-pivot), flag&&i==m);
     }
     if(!flag)  dp[pos][pivot][torques]=ans;
     /*
      *  1、这里相对前面的模板不同。 这里记忆化对我来说又得注释一下，
      *     这里高位与低位相同时，
      *     当前pos是不能记忆的因为这里只枚举了0-bit[i]位，不符合总的dp[][][]状态的定义
      *     pos位，pivot点，扭矩和为torques的所有数 的个数
      *  2、同样也可以按前面的模板来写，不过需要对每个数的dp进行memset()。
      *
      * 对比下二者的时间，156 : 249
     */
     return ans;
 }
 LL solve(LL x){
     if(x < )    return ;
     memset(bit, , sizeof(bit));
     int len = ;
     while(x){
         bit[++len] = x%;
         x /= ;
     }
     LL ans = ;
     for(int i=; i<=len; i++){
         ans += dfs(len, i, , true);
     }
     return ans-(len-);
     /*
      * 这里结果减去(len-1)我又没想到，在纸上画了画，
      * 发现在dfs过程中，重复计算了一种为0的情况，
      * 这个情况要筛去(len-1)个
     */
 }
 int main(){
     int T;
     scanf("%d", &T);
     memset(dp, -, sizeof(dp));
     while(T--){
         LL x, y;
         scanf("%lld%lld", &x, &y);
         printf("%lld\n", solve(y)-solve(x-));
     }
 }

还有道C，改天补。

这里想到了dp第一天韦神对A题有一种不同于上面那种解法的解法，因为代码看着比较复杂，一直没有仔细看，只是粗略的对比了二份代码的不同，发现那个思路比较注重对各种情况的全面讨论，难点在于对状态的抽象以及转移过程中的分类讨论，但是dp的维度是优于这个的，情况的表示也相对直观。这里先放上代码，改日细看。

 #include <stdio.h>
 #include <string.h>
 #include <string.h>
 #include <iostream>
 using namespace std;
 int dp[][];//dp[i][j]，i代表数字的位数，j代表状况
 //dp[i][0],表示不存在不吉利数字
 //dp[i][1],表示不存在不吉利数字，且最高位为2
 //dp[i][2],表示存在不吉利数字
 void Init()
 {
     memset(dp,,sizeof(dp));
     int i;
     dp[][] = ;
     for(i = ; i<=; i++)//数字最长为6
     {
         dp[i][] = dp[i-][]*-dp[i-][];//最高位加上不含4的9个数字的状况，但因为会放6，所以要减去前一种开头为2的情况
         dp[i][] = dp[i-][];//开头只放了2
         dp[i][] = dp[i-][]*+dp[i-][]+dp[i-][];//已经含有的前面放什么数都可以，或者是放一个4，或者是在2前面放6
     }
 }

 int solve(int n)
 {
     int i,len = ,tem = n,ans,flag,a[];
     while(n)//将每一位拆分放入数组
     {
         a[++len] = n%;
         n/=;
     }
     a[len+] = ans = ;
     flag = ;
     int bb=;
     for(i=len; i>=; i--)
     {
         ans+=dp[i-][]*a[i];
         if(!flag && a[i]>)//首位大于4，可以有放4的情况
             ans+=dp[i-][];
         if(!flag && a[i+]== && a[i]>)//后一位为6，此位大于2
             ans+=dp[i][];
         if(!flag && a[i]>)//此位大于6，可能的62状况
             ans+=dp[i-][];
         if(a[i]== || (a[i+]==&&a[i]==)){
             bb=;
             for(int j=i-;j>=;j--){
                 bb=bb*+a[j];
             }
             break;
         }
     }
    return tem-ans-bb;
 }

 int main()
 {
     int l,r;
     Init();
     while(~scanf("%d%d",&l,&r),l+r)
     {
     // solve(4555);
         printf("%d\n",solve(r+)-solve(l));
         //因为solve函数中并没有考虑n是不是不幸数的情况，所以r+1只算了1~r，而l只算了1~l-1,这两者相减才是正确答案
    }

     return ;
 }