loj 6037 「雅礼集训 2017 Day4」猜数列 - 动态规划

题目传送门

　　传送门

题目大意

　　有一个位置数列，给定$n$条线索，每条线索从某一个位置开始，一直向左或者向右走，每遇到一个还没有在线索中出现的数就将它加入线索，问最小的可能的数列长度。

　　依次从左到右考虑每一位上填的数。

　　用$f_{L, a, R, b, S}$表示正在满足向右走的线索是$L$，前$a$个字符已经满足，正在满足向左走的线索是$R$，前$b$个字符还没有满足，还未被考虑的线索集合是$S$。

　　主要有两种转移：

• 填下一个字符
  • 如果两个线索下一个要填的字符相同，那么直接填
  • 如果不同则还需判断一下是否会使得另一线索不满足条件。
• 更换线索
  • 向右走的线索是一堆类似于后缀的东西，向左走的线索是一堆类似于前缀的东西
  • 能不能在某个串的某个位置处更换某个串可以预处理出来

　　loj上加了一堆常数优化卡到rk 1，估计很快就被超了。

　　记得Doggu指着Claris这道题的非记忆化搜索写法给我说以后见着Claris记着%。

Code

 /**
  * loj
  * Problem#6037
  * Accepted
  * Time: 1224ms
  * Memory: 25208k
  */
 #include <iostream>
 #include <cstdlib>
 #include <cstdio>
 #include <set>
 using namespace std;
 typedef bool boolean;

 const int N = ;
 const int Lim =  << ;

 #define last_one(__x) (__builtin_ffs(__x) - 1)

 int n;
 int len[N];
 int s[N][N];
 int exi[N][N];
 int can[N][N];    // L: forward, R: backward
 int usable[N][N];
 int f[N][N][N][N][];

 inline void init() {
     scanf("%d", &n);
     set<int> ss;
     for (int i = , x; i < n; i++) {
         int l = , hash_val = ;
         while (~scanf("%d", &x) && x) {
             s[i][l++] = x;
             hash_val = hash_val *  + x;
         }
         len[i] = l, s[i][l] = ;
         if (ss.count(hash_val))
             n--, i--;
         else
             ss.insert(hash_val);
     }

     for (int i = ; i < n; i++)
         for (int j = ; j < len[i]; j++)
             exi[i][j + ] = exi[i][j] | ( << s[i][j]);
 }

 // start at pos
 boolean check(int a, int pos, int b) {
     int *pa = s[a] + pos, *pb = s[b];
     while (*pa || *pb) {
         if (*pa == *pb)
             pa++, pb++;
         else if (( << *pb) & exi[a][pa - s[a]])
             pb++;
         else
             return false;
     }
     return true;
 }

 void upd(int& a, int b) {
     if (a > b)
         a = b;
 }

 // considering s[L][pl], s[R][pr - 1], S remained
 int dp(int L, int pl, int R, int pr, int S) {
     if (!S && pl == len[L] && !pr)
         return ;
     int &rt = f[L][pl][R][pr][S];
     if (rt)
         return rt;
     rt = Lim;

     for (int T = S & can[L][pl], i = last_one(T); T; T -= (T & (-T)), i = last_one(T))
         upd(rt, dp(i, , R, pr, S ^ ( << i)));
     if (!pr) {
         for (int i = ; i < n && (S >> i); i++)
             if ((S >> i) & )
 //                for (int j = 0; j <= len[i]; j++)
 //                    if ((can[i][j] >> R) & 1)
 //                        upd(rt, dp(L, pl, i, j, S ^ (1 << i)));
                 for (int T = usable[R][i], j = last_one(T); T; T -= (T & (-T)), j = last_one(T))
                     upd(rt, dp(L, pl, i, j, S ^ ( << i)));
     }

     if (pl < len[L] || pr) {
         int vl = s[L][pl], vr = ((pr) ? (s[R][pr - ]) : ());
         if (vl == vr)
             upd(rt, dp(L, pl + , R, pr - , S) + );
 //        if (pl < len[L] && _exi[R][pr] & (1 << vl))
         if (pl < len[L] && exi[R][pr] & ( << vl))
             upd(rt, dp(L, pl + , R, pr, S) + );
         if (pr && exi[L][pl] & ( << vr))
             upd(rt, dp(L, pl, R, pr - , S) + );
     }
 //    cerr << L << " " << pl << " " << R << " " << pr << " " << S  << " " << rt << '\n';
     return rt;
 }

 inline void solve() {
     // forward
     for (int idx = ; idx < n; idx++) {
         for (int pos = ; pos <= len[idx]; pos++) {
             for (int ano = ; ano < n; ano++) {
                 if (ano ^ idx)
                     can[idx][pos] |= check(idx, pos, ano) << ano;
             }
 //            cerr << can[idx][pos] << ' ';
         }
     }
     for (int i = ; i < n; i++) {
         for (int j = ; j < n; j++) {
             if (i ^ j) {
                 for (int pos = ; pos <= len[j]; pos++)
                     if ((can[j][pos] >> i) & )
                         usable[i][j] |= ( << pos);
             }
         }
     }
     len[n] = ;
     for (int i = ; i < N; i++) {
         exi[n][i] = ; //_exi[n][i] = 2046;
         can[n][i] = ;
     }
     int all = ( << n) - , ans = Lim;
 //    ans = dp(n, 0, 1, len[1], all ^ 2);
     for (int i = ; i < n; i++) {
         upd(ans, dp(n, , i, len[i], all ^ ( << i)));
     }
     if (ans == Lim)
         puts("-1");
     else
         printf("%d\n", ans);
 }

 int main() {
     init();
     solve();
     return ;
 }