HDU 4057：Rescue the Rabbit（AC自动机+状压DP）***

http://acm.hdu.edu.cn/showproblem.php?pid=4057

题意：给出n个子串，串只包含‘A’,'C','G','T'四种字符，你现在需要构造出一个长度为l的串，如果这个串里面包含了某个子串，那么答案就会+val[i]（如果这个串被使用过了，就不会再有贡献了），要使得构造出来的串的答案最大，问是多少。

思路：只能想到是AC自动机的题目，然后乱搞出一个错误的方法，没想到是这样的操作。

n只有10，因此才1024，开一个dp[l][sz][st]的数组，l代表当前的字符串长度，sz代表当前遍历的结点，st代表当前的状态（二进制表示使用了哪些字符串），这里的长度用滚动数组优化。

方程：dp[now][nxt[j][x]][k|val[nxt[j][x]]] = dp[pre][j][k]; (当且仅当dp[pre][j][k]状态可取)

nxt[j][x]代表j结点的下一个状态，val[now]代表now这个结点是哪个字符串的终点，因此k|val[nxt[j][x]]就是当前拥有的字符串的状态+下一个结点拥有的字符串的状态。

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <queue>
 using namespace std;
 #define N 1010
 #define INF 0x3f3f3f3f
 int nxt[N][], fail[N], val[N], rt, sz, n, l, num[];
 bool dp[][N][(<<)+];
 char s[];
 int newnode() {
     for(int i = ; i < ; i++) nxt[sz][i] = -;
     val[sz++] = ;
     return sz - ;
 }
 void init() {
     sz = ; rt = newnode();
 }
 int Turn(char c) {
     if(c == 'A') return ;
     if(c == 'C') return ;
     if(c == 'G') return ;
     return ;
 }
 void Insert(int id) {
     int len = strlen(s);
     int now = rt;
     for(int i = ; i < len; i++) {
         int c = Turn(s[i]);
         if(nxt[now][c] == -) nxt[now][c] = newnode();
         now = nxt[now][c];
     }
     val[now] |= ( << id);
 }
 void Build() {
     queue<int> que;
     while(!que.empty()) que.pop();
     fail[rt] = rt;
     for(int i = ; i < ; i++) {
         if(nxt[rt][i] == -) nxt[rt][i] = rt;
         else fail[nxt[rt][i]] = rt, que.push(nxt[rt][i]);
     }
     while(!que.empty()) {
         int now = que.front(); que.pop();
         val[now] |= val[fail[now]]; // 如果fail指向的结点是有状态的,应该加上!!!
         for(int i = ; i < ; i++) {
             if(nxt[now][i] == -) nxt[now][i] = nxt[fail[now]][i];
             else fail[nxt[now][i]] = nxt[fail[now]][i], que.push(nxt[now][i]);
         }
     }
 }
 void Solve() {
     int pre = , now = ;
     memset(dp, , sizeof(dp));
     dp[pre][][] = ;
     for(int i = ; i < l; i++) {
         memset(dp[now], , sizeof(dp[now]));
         for(int j = ; j < sz; j++) {
             for(int k = ; k < ( << n); k++) {
                 if(!dp[pre][j][k]) continue;
                 for(int x = ; x < ; x++) {
                     dp[now][nxt[j][x]][k|val[nxt[j][x]]] = dp[pre][j][k]; // 哪些状态可以取
                     // nxt[j][x] 下一个结点
                     // k | val[nxt[j][x]] 当前状态加上下一个结点有的状态
                 }
             }
         }
         swap(now, pre);
     }
     int ans = -INF, res; now = l % ;
     for(int i = ; i < sz; i++) {
         for(int j = ; j < ( << n); j++) {
             if(!dp[now][i][j]) continue;
             res = ;
             for(int k = ; k < n; k++)
                 if(j & ( << k)) res += num[k];
             ans = ans > res ? ans : res;
         }
     }
     if(ans >= ) printf("%d\n", ans);
     else puts("No Rabbit after 2012!");
 }

 int main() {
     while(~scanf("%d%d", &n, &l)) {
         init();
         for(int i = ; i < n; i++) scanf("%s %d", s, &num[i]), Insert(i);
         Build();
         Solve();
     }
     return ;
 }

 /*
 3 2
 A -1
 G -1
 C -1
 */