DP套DP

DP套DP，就是将内层DP的结果作为外层DP的状态进行DP的方法。

[BZOJ3864]Hero meet devil

对做LCS的DP数组差分后状压，预处理出转移数组，然后直接转移即可。

tr[S][k]表示当前差分状压后的状态为S，加入字符k(k为ACGT中一个)后会转移到什么状态。

f[i][S]表示串已构造到第i位，和模式串的匹配状态差分后为S，的方案数。

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define rep(i,l,r) for (int i=(l); i<=(r); i++)
 typedef long long ll;
 using namespace std;

 const int N=,M=,mod=1e9+;
 int T,n,m,d[],g[],ans[N],tr[M][],cnt[M],f[][M];
 char s[],c[]="ACGT";

 int main(){
     freopen("bzoj3864.in","r",stdin);
     freopen("bzoj3864.out","w",stdout);
     for (scanf("%d",&T); T--; ){
         scanf("%s%d",s+,&m); n=strlen(s+);
         for (int S=; S<<<n; S++){
             if (S) cnt[S]=cnt[S^(S&-S)]+;
             rep(i,,n-) d[i+]=d[i]+((S>>i)&);
             rep(k,,){
                 rep(i,,n) g[i]=max(max(d[i],g[i-]),(c[k]==s[i])?d[i-]+:);
                 tr[S][k]=;
                 rep(i,,n-) if (g[i+]-g[i]) tr[S][k]|=<<i;
             }
         }
         memset(ans,,sizeof(ans)); memset(f,,sizeof(f)); f[][]=;
         rep(i,,m){
             int v=i&,u=v^; memset(f[v],,sizeof(f[v]));
             for (int S=; S<<<n; S++)
                 rep(k,,) f[v][tr[S][k]]=(f[v][tr[S][k]]+f[u][S])%mod;
         }
         for (int S=; S<<<n; S++) ans[cnt[S]]=(ans[cnt[S]]+f[m&][S])%mod;
         rep(i,,n) printf("%d\n",ans[i]);
     }
     return ;
 }

[BZOJ5336][TJOI2018]party

同上题，多加一维0/1/2表示末尾和'NOI'匹配到第几位即可。

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define rep(i,l,r) for (int i=(l); i<=(r); i++)
 typedef long long ll;
 using namespace std;

 const int N=,M=,mod=1e9+;
 int T,n,m,d[],g[],ans[N],tr[M][],cnt[M],f[][M][];
 char s[],c[]="NOI";

 int main(){
     freopen("bzoj5336.in","r",stdin);
     freopen("bzoj5336.out","w",stdout);
     scanf("%d%d%s",&m,&n,s+);
     for (int S=; S<<<n; S++){
         if (S) cnt[S]=cnt[S^(S&-S)]+;
         rep(i,,n-) d[i+]=d[i]+((S>>i)&);
         rep(k,,){
             rep(i,,n) g[i]=max(max(d[i],g[i-]),(c[k]==s[i])?d[i-]+:);
             tr[S][k]=;
             rep(i,,n-) if (g[i+]-g[i]) tr[S][k]|=<<i;
         }
     }
     f[][][]=;
     rep(i,,m){
         int v=i&,u=v^; memset(f[v],,sizeof(f[v]));
         for (int S=; S<<<n; S++) rep(l,,) if (f[u][S][l]){
             rep(k,,){
                 int S1=tr[S][k],l1=l;
                 l1=(k==l) ? l1+ : ((!k)?:);
                 if (l1<) f[v][S1][l1]=(f[v][S1][l1]+f[u][S][l])%mod;
             }
         }
     }
     for (int S=; S<<<n; S++)
         rep(i,,) ans[cnt[S]]=(ans[cnt[S]]+f[m&][S][i])%mod;
     rep(i,,n) printf("%d\n",ans[i]);
     return ;
 }

[BZOJ3591]最长上升子序列

给出1~n的一个排列的一个最长上升子序列，求原排列可能的种类数。

考虑最长上升子序列$O(n\log n)$算法中使用的单调队列，将单调队列中的数组成的集合作为状态DP。

f[S]表示当前状态S的方案数，其中S是一个三进制数，第i位为0表示这个数尚未被选入数列，1表示选入数列但不在单调队列中，2表示在单调队列中。

对于每个状态，枚举下一个加入序列的数是什么来转移。可以先预处理减小常数。

具体细节可看代码注释，$O(2^n n^2+3^n n)$

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define rep(i,l,r) for (int i=(l); i<=(r); i++)
 using namespace std;

 const int N=,M=1.5e7;
 int n,m,x,id[N],p[N],f[M];
 bool flag[<<N][N];
 int v[<<N][N],c[<<N],mx[<<N],s[<<N],ans=;

 int main(){
     freopen("bzoj3591.in","r",stdin);
     freopen("bzoj3591.out","w",stdout);
     scanf("%d%d",&n,&m);
     rep(i,,m) scanf("%d",&x),id[x-]=i;
     p[]=; rep(i,,n) p[i]=p[i-]*;
     for (int S=; S<(<<n); S++)//预处理出每个可能的状态转移，S为当前已经选进单调队列的集合，flag表示能否转移，v是转移到什么位置
         rep(i,,n-){
             if (S&(<<i)){ c[S]+=p[i]; mx[S]=max(mx[S],i); s[S]++; continue; }
             //c:全1的三进制状态，mx:最大数，s:popcount
             if (!id[i]) flag[S][i]=;
             else{
                 int tot=;
                 rep(j,,n-) if (S&(<<j) && id[j]) tot++;
                 if (tot+==id[i]) flag[S][i]=;//满足在LIS中的位置为id[i]
             }
             int t=-,x=;
             rep(j,,n-) if (S&(<<j)) x+=p[j];//S转三进制
             for (int j=n-; j>i; j--) if (S&(<<j)) t=j;//找到集合中比i大的最小的数更新
             if (~t) v[S][i]=x-p[t]+p[i]; else v[S][i]=x+p[i];
         }
     f[]=;
     for (int x=; x<(<<n); x++)
         for (int y=x; y> || (!y && !x); (!x) ? y-- : y=(y-)&x)//x为已在序列中的数的集合，y为在单调队列中数的集合
             if (f[c[x]+c[y]]){
                 int t=c[x]+c[y];
                 for (int i=; s[y]==m ? i<mx[y] : i<n; i++)//枚举新加进序列的数（若单调队列长度已满则不能加入更大的数）
                     if (flag[x][i]) f[c[x]+p[i]+v[y][i]]+=f[t];//新加进序列的数一定也加进单调队列
                 if (x==(<<n)-) ans+=f[t];
             }
     printf("%d\n",ans);
     return ;
 }