hdu 4352 "XHXJ's LIS"（数位DP+状压DP+LIS）

传送门

参考博文：

　　[1]:http://www.voidcn.com/article/p-ehojgauy-ot.html

题解：

　　将数字num字符串化；

　　求[L,R]区间最长上升子序列长度为 K 的总个数；

题解：

　　也不算是题解，只是谈谈我对此题解法的理解；

　　学到数位DP的话，应该已经学过状压DP 和 LIS O( nlog(n) )解法吧（默认学过了）；

　　对于此题，一共就10个不同的数字 "0~9"，对于长度为 K 的最长上升子序列，如果不适用记忆化搜索的话，一定会重复计算好多好多次；

　　例如，如果 K = 10，那么，最长上升子序列一定顺序包含 0 1 2 3 4 5 6 7 8 9 这十个数字，而最多可以达到19位；

　　那么，除这十位外，还有 9 位可以由 0~9 的任意数字随机排列组成，那么重复计算的次数是非常多的。

　　关键就是如何记录已经求过的状态？

　　首先介绍一下此题如何使用状压；

　　正如上例，我们只需关注 0~9 这十个数字是否出现过，以及是否按顺序出现，而不必关心其他位数是由什么组成的，

　　那么，这就要用到状压DP的思想了；

　　对于 0~9 这十位数：

　　9　　8　　7　　6　　5　　4　　3　　2　　1　　0

　　_　　_　　_　　_　　_　　_　　_　　_　　_　　_

　　每个数字下的横杠可填 0 或 1 这两个数；

　　0：不含当前数字；

　　1：含有当前数字；

　　那么，对于状态 state ，判断其是否含有数字 i ，只需判断 state&(1<<i) 是否为 1 即可；

　　首先是预处理：

　　定义 lis[ i ] : 状态 i 的最长上升子序列的长度

 for(int i=;i < <<;++i)
 {
     lis[i]=;
     for(int j=;j < ;++j)
         lis[i] += (i&(<<j)) ? :;
 }

　　接下来，看看这个代码的作用：

 int LIS(int state,int num)
 {
     for(int i=num;i < ;++i)
         if(state&(<<i))
             return (state^(<<i))|(<<num);
     return state|(<<num);
 }

　　笼统的解释一下就是：插入 num 后，将 state 中的第一个大于等于 num 位的 1 变为 0，并将 num 位 置为 1；

　　例如，假设 state = (1,000,110,001)₍₂₎;

　　可得，当前 state 已经形成了由 0,4,5,9 构成的长度为 4 的最长上升子序列；

　　如果当前加入的数字为 3 ，根据 LIS 的思想，在之前形成的最长上升子序列中找到第一个大于等于 3 的数，

　　并将3和其互换，那么返回的值就是 (1,000,101,001)₍₂₎;

　　那么，这段代码到底是干啥用的呢？

　　定义dp[ curPos ][ state ][ K ] : 来到curPos 位置时，状态为 state 所形成的最长上升子序列长度为 K 的总个数；

　　核心代码：

 ll DFS(int curPos,int state,bool lead,bool limit)
 {
     if(curPos == -)
         return lis[state] == K ? :;
     if(!limit&&dp[curPos][state][K] != -)
         return dp[curPos][state][K];

     int up=limit ? digit[curPos]:;
     ll ans=;
     for(int i=;i <= up;++i)
         ans += DFS(curPos-,lead&&i== ? :LIS(state,i),lead&&i==,limit&&i==digit[curPos]);

     if(!limit)
         dp[curPos][state][K]=ans;

     return ans;
 }

　　1~9行不再赘述；

　　主要看一下第11行的作用；

　　第二个参数赋的值为 lead&&i==0 ? 0:LIS(state,i) ，给下一个状态赋 0 很好理解，关键是 LIS(state,i)；

　　这就对应着上述对 LIS() 的解释；

AC代码：

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 using namespace std;
 #define ll long long
 #define mem(a,b) memset(a,b,sizeof(a))

 ll N,M;
 int K;
 int digit[];
 ll dp[][<<][];
 int lis[<<];

 int LIS(int state,int num)
 {
     for(int i=num;i < ;++i)
         if(state&(<<i))
             return (state^(<<i))|(<<num);
     return state|(<<num);
 }
 ll DFS(int curPos,int state,bool lead,bool limit)
 {
     if(curPos == -)
         return lis[state] == K ? :;
     if(!limit&&dp[curPos][state][K] != -)
         return dp[curPos][state][K];

     int up=limit ? digit[curPos]:;
     ll ans=;
     for(int i=;i <= up;++i)
         ans += DFS(curPos-,lead&&i== ? :LIS(state,i),lead&&i==,limit&&i==digit[curPos]);

     if(!limit)
         dp[curPos][state][K]=ans;

     return ans;
 }
 ll Solve(ll x)
 {
     int k=;
     while(x)
     {
         digit[k++]=x%;
         x /= ;
     }
     return DFS(k-,,true,true);
 }
 int main()
 {
     int test;
     scanf("%d",&test);
     mem(dp,-);

 for(int i=;i < <<;++i)
 {
     lis[i]=;
     for(int j=;j < ;++j)
         lis[i] += (i&(<<j)) ? :;
 }
     for(int kase=;kase <= test;++kase)
     {
         scanf("%lld%lld%d",&N,&M,&K);
         printf("Case #%d: %lld\n",kase,Solve(M)-Solve(N-));
     }
     return ;
 }

　　

　　当然，也可提前预处理出状态 i 插入数字 j 后形成的状态，这就对应着参考博文中的 nex[][] 数组；