数位DP之小小结

资料链接：http://wenku.baidu.com/view/9de41d51168884868662d623.html

http://wenku.baidu.com/view/d2414ffe04a1b0717fd5dda8.html

几位大大的数位BLOG:http://www.cnblogs.com/jackge/archive/2013/05/15/3080958.html

http://www.cnblogs.com/kuangbin/category/476047.html

CXLOVE:http://blog.csdn.net/acm_cxlove/article/details/7819907

给出数位DP的DFS记忆化DP模板；

因为原理比较简单，不用去构造方程，而且简洁。。

ll dfs(int pos,int cet,int sum,int flag){
   if (sum<) return ;
   if (pos<=) return sum==;
   if (!flag&&dp[pos][cet][sum]!=-) return dp[pos][cet][sum];
       int end=flag?a[pos]:;
   ll ret=;
   for (int i=;i<=end;i++)
   ret+=dfs(pos-,cet,sum+i*(pos-cet),flag&&(end==i));
   if (!flag) dp[pos][cet][sum]=ret;
   return ret;

}

复杂度是DP方程的状态数，DP设计的好坏与DP的状态数有关。。

FLAG表示是否在边界，当不再边界时我们可以做无关后面数的操作，否则，要考虑后面的数对前面有没有影响。。

我做的几道题：

HDU 3652:

 #include<stdio.h>
 #include<string.h>
 #include<algorithm>
 #include<math.h>
 #include<iostream>
 using namespace std;
 int a[];
 int len;
 int dp[][][][];

 int dfs(int pos,int sum,int res,int last,int flag)
 {
     if (pos<) return res&&(sum==);
     if (!flag&&dp[pos][sum][res][last]!=-) return dp[pos][sum][res][last];
     int end=flag?a[pos]:;
     int ret=;
     for (int i=;i<=end;i++)
     ret+=dfs(pos-,(sum*+i)%,res||(last==&&i==),i,flag&&i==end);
     if (!flag) dp[pos][sum][res][last]=ret;
     return ret;
 }

 int get(int x)
 {
     len=;
     while (x){
             a[len++]=x%;
             x/=;
     }
     return dfs(len-,,,,);
 }

 int main()
 {
     int n;
     memset(dp,-,sizeof(dp));
     while (scanf("%d",&n)!=EOF)
     {
         printf("%d\n",get(n));
     }
 }

HDU  3555:

 #include<stdio.h>
 #include<string.h>
 #include<algorithm>
 #include<math.h>
 #include<iostream>
 using namespace std;
 typedef long long ll;
 int a[];
 int len;
 ll dp[][][];

 ll dfs(int pos,int res,int last,int flag)
 {
     if (pos<) return res;
     if (!flag&&dp[pos][res][last]!=-) return dp[pos][res][last];
     int end=flag?a[pos]:;
     ll ret=;
     for (int i=;i<=end;i++)
     ret+=dfs(pos-,res||(last==&&i==),i,flag&&i==end);
     if (!flag) dp[pos][res][last]=ret;
     return ret;
 }

 ll get(ll x)
 {
     len=;
     while (x){
             a[len++]=x%;
             x/=;
     }
     return dfs(len-,,,);
 }

 int main()
 {
     ll n;
     int T;
     scanf("%d",&T);
     memset(dp,-,sizeof(dp));
     while (T--)
     {
         scanf("%I64d",&n);
         printf("%I64d\n",get(n));
     }
 }

HDU 4389:有打表方法；每个100000个数打表，再统计；

数位DP代码:

 #include<stdio.h>
 #include<string.h>
 #include<algorithm>
 #include<math.h>
 typedef long long ll;
 #define mod 2520
 int inx[];
 ll dp[][][];
 int a[];
 using namespace std;

 void init(){
     int num=;
     for (int i=;i<=mod;i++)
     if (mod%i==) inx[i]=++num;
 }

 int gcd(int a,int b){
     if (a%b==) return b;
     return gcd(b,a%b);
 }

 int lcm(int a,int b){
     return a*b/gcd(a,b);
 }

 ll dfs(int pos,int slcm,int sum,int flag){
    if (pos<) return sum%slcm==;
    if (!flag&&dp[pos][inx[slcm]][sum]!=-) return dp[pos][inx[slcm]][sum];
    int end=flag?a[pos]:;
    ll ret=;
    for (int i=;i<=end;i++){
    int nowlcm=slcm;
    int nowsum=(sum*+i) %mod;
    if (i) nowlcm=lcm(nowlcm,i);
    ret+=dfs(pos-,nowlcm,nowsum,flag&&i==end);
    }
    if (!flag) dp[pos][inx[slcm]][sum]=ret;
    return ret;
 }

 ll get(ll x)
 {
     int pos=;
     while (x)
     {
      a[pos++]=x%;
      x/=;
     }
     return dfs(pos-,,,);
 }

 int main(){
     int T;
     scanf("%d",&T);
     memset(dp,-,sizeof(dp));
     init();
     while (T--){
         ll a,b;
         scanf("%I64d%I64d",&a,&b);
         printf("%I64d\n",get(b)-get(a-));
     }
     return ;
 }

这里我们不可能保存每个值去除以其数位的和，我们可以枚举数位的和，然后DFS能满足的数的个数，再看其数能不能整除其数位。

数位和的状态是1-81。。。；

HDU 4334 :

 #include<stdio.h>
 #include<algorithm>
 #include<math.h>
 #include<string.h>
 #include<algorithm>

 using namespace std;
 int bit[];
 int dp[][];

 int dfs(int t,int num,int flag)
 {
     if (t==) return num>=;
     if (num<) return ;
     if (!flag&&dp[num][t]!=-) return dp[num][t];
     int ans=;
     int  end=flag?bit[t]:;
     for (int i=;i<=end;i++)
          ans+=dfs(t-,num-i*(<<(t-)),flag&&i==end);
     if (!flag) dp[num][t]=ans;
     return ans;
 }
 int main()
 {
     int T;
     scanf("%d",&T);
     memset(dp,-,sizeof(dp));
     for (int i=;i<=T;i++)
     {
         int a,b;
         scanf("%d%d",&a,&b);
         int t=;
         int  ans=;
         while (a)
         {
             ans+=a%*(<<t);
             t++;
             a/=;
         }
         int len=;
         while (b)
         {
             bit[++len]=b%;
             b/=;
         }
         printf("Case #%d: %d\n",i,dfs(len,ans,));
     }
     return ;
 }

前面的做了差不多，这也是简单题了，先预处理F[A],然后处理。。

codeforces 55D: http://codeforces.com/problemset/problem/55/D

比较麻烦的题；求一个范围的书能被其数位整除的个数。

切题点：1-9的公倍数为2520;

我们可以定义方程DP[POS][LCM][SUM]表示：处理第POS位，其数位的最小公倍数数多少，该数MOD2520是多少，但是有个问题会爆内存，

要开DP[20][2520][2520];

解决办法是：2520=2^3*3^2*5*7

y于是又4*3*2*2= 48中组合。。

我们可以对LCM用下标代替，就不会爆内存了。。。真是奇妙的方法。。

 #include<stdio.h>
 #include<string.h>
 #include<algorithm>
 #include<math.h>
 typedef long long ll;
 #define mod 2520
 int inx[];
 ll dp[][][];
 int a[];
 using namespace std;

 void init(){
     int num=;
     for (int i=;i<=mod;i++)
     if (mod%i==) inx[i]=++num;
 }

 int gcd(int a,int b){
     if (a%b==) return b;
     return gcd(b,a%b);
 }

 int lcm(int a,int b){
     return a*b/gcd(a,b);
 }

 ll dfs(int pos,int slcm,int sum,int flag){
    if (pos<) return sum%slcm==;
    if (!flag&&dp[pos][inx[slcm]][sum]!=-) return dp[pos][inx[slcm]][sum];
    int end=flag?a[pos]:;
    ll ret=;
    for (int i=;i<=end;i++){
    int nowlcm=slcm;
    int nowsum=(sum*+i) %mod;
    if (i) nowlcm=lcm(nowlcm,i);
    ret+=dfs(pos-,nowlcm,nowsum,flag&&i==end);
    }
    if (!flag) dp[pos][inx[slcm]][sum]=ret;
    return ret;
 }

 ll get(ll x)
 {
     int pos=;
     while (x)
     {
      a[pos++]=x%;
      x/=;
     }
     return dfs(pos-,,,);
 }

 int main(){
     int T;
     scanf("%d",&T);
     memset(dp,-,sizeof(dp));
     init();
     while (T--){
         ll a,b;
         scanf("%I64d%I64d",&a,&b);
         printf("%I64d\n",get(b)-get(a-));
     }
     return ;
 }

FZU 2113:

OJ挂了，现在也没评测出来。。

求一个范围[L,R]数中1的总数。。

方程想到就是超级大水题；

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<cmath>
typedef long long ll;
int a[];
ll dp[][];
using namespace std;

ll dfs(int pos,int num,int flag)
{
    if (pos<) return num;
    if (!flag&&dp[pos][num]!=-) return dp[pos][num];
    int end=flag?a[pos]:;
    ll ret=;
    for (int i=;i<=end;i++)
        if (i==) ret+=dfs(pos-,num+,flag&&end==i);
        else ret+=dfs(pos-,num,flag&&end==i);
    if (!flag) dp[pos][num]=ret;
    return ret;
}

ll get(ll x)
{
    int pos=;
    while (x){
        a[pos++]=x%;
        x/=;
    }
    return dfs(pos,,);
}

int main()
{
    ll a,b;
    memset(dp,-,sizeof(dp));
    while (scanf("%lld%lld",&a,&b)!=EOF){
          printf("%lld\n",get(b)-get(a-));
    }
    return ;
}

还有好多好多各种状态的数位DP题，果然太弱切不动。。