【dp 状态压缩 单调栈】bzoj3591: 最长上升子序列

奇妙的单调栈状压dp

Description

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

Input

第一行一个整数n。

第二行一个整数k，表示最长上升子序列的长度。

第三行k个整数，表示这个最长上升子序列。

Output

第一行一个整数，表示原排列可能的种类数。

Sample Input

5
3
1 3 4

Sample Output

11

HINT

【样例说明】

11种排列分别为(1, 3, 2, 5, 4), (1, 3, 5, 2, 4), (1, 3, 5, 4, 2), (1, 5, 3, 2, 4), (1, 5, 3, 4, 2), (2, 1, 3, 5, 4), (2, 1, 5, 3, 4), (2, 5, 1, 3, 4), (5, 1, 3, 2, 4), (5, 1, 3, 4, 2), (5, 2, 1, 3, 4)。

【数据规模和约定】

对于30%的数据，1 <= n <= 11。

对于70%的数据，1 <= n <= 14。

对于100%的数据，1 <= n <= 15，答案小于2^31。

---

题目分析

这种属于奇奇怪怪的状压dp：把单调栈拿来状压。

考虑求解LIS，是一个使用单调栈的过程。因此按序列位置依次考虑，每一个数有三种状态：0:没有被考虑；1:考虑了，在栈里；2:考虑了，已出栈————自然可以三进制状压表示。

再考虑dp的过程：用$f[i]$表示$i$这个三进制状态下的合法方案数。转移时则从小到大枚举每一个数，看其是否能够通过当前状态合法转移至下一个LIS（注意判断转移前的合法性）。

转移不难，重点在于想到状压每个数对于单调栈的状态。

 #include<bits/stdc++.h>
 const int maxn = ;

 int val[maxn],base[maxn],n,m;
 int num[maxn],pre[maxn];
 int LIS[maxn],cnt;
 int f[],ans;　　　　　　//f[]不要忘记开大，表示3^n种状态

 int read()
 {
     char ch = getchar();
     int num = ;
     bool fl = ;
     for (; !isdigit(ch); ch = getchar())
         if (ch=='-') fl = ;
     for (; isdigit(ch); ch = getchar())
         num = (num<<)+(num<<)+ch-;
     if (fl) num = -num;
     return num;
 }
 int main()
 {
     n = read(), m = read(), num[] = ;
     for (int i=; i<=m; i++)
     {
         num[i] = read()-, pre[num[i]] = i-;
         if (num[i] < num[i-]){
             puts("");
             return ;
         }
     }
     base[] = ;
     for (int i=; i<=n; i++) base[i] = base[i-]*;
     f[] = ;
     for (int i=; i<base[n]; i++)
         if (f[i]){
             int st = i,done,cnt,ins;
             done = cnt = ins = ;
             for (int j=; j<n; j++)
             {
                 val[j] = st%, st /= ;
                 if (val[j]) done++;
                 if (val[j]==) LIS[cnt++] = j;
             }
             if (done==n){
                 ans += f[i];
                 continue;
             }
             for (int j=; j<n; j++)
             {
                 if (val[j]) continue;
                 if (pre[j]&&!val[num[pre[j]]]) continue;
                 while (LIS[ins] < j&&ins < cnt) ins++;
                 if (ins==m) continue;
                 int nxt = i+base[j];
                 if (ins < cnt) nxt += base[LIS[ins]];
                 f[nxt] += f[i];
             }
         }
     printf("%d\n",ans);
     return ;
 }

END