hdu 4057 Rescue the Rabbit

题意

　　给出n(n<=10)个串，每个串有个权值，然后让你构造一个长度为l(l<=100)的串，如果他包含给出的串就得到相应的权值，求可能得到的最大权值

解法

　　AC自动机+DP，很显然要建立自动机，然后在上面跑，如果不要求每个串的权值只能获取一次，那么直接跑来跑去的就行，但是因为只能取一次，串很少，可以状态压缩DP,dp[i][j][k]记录前i个字符走到j状态并且已经获得的串状态为k时的最优解。需要滚动数组优化空间--

 #include<cstdio>
 #include<cstring>
 #include<queue>
 #include<algorithm>
 using namespace std;
 const int N = ;
 const int inf = ~0u>>;
 int hash[];
 struct node{
     node *ch[],*fail;
     int mask;
     void clear(){
         for(int i = ;i < ;i++)ch[i] = NULL;fail = NULL;
         mask = ;
     }
 };
 node stk[N*];
 bool dp[][N][];
 int score[];
 struct Trie{
     node *root;int top;
     node* newnode(){
         node *p = &stk[top++];
         p -> clear();
         return p;
     }
     void init(){
         top = ;
         root = newnode();
     }
     void insert(char *s,int number){
         node *p = root;int len = strlen(s);
         for(int i = ;i < len;i++){
             int id = hash[s[i]];
             if(p -> ch[id] == NULL)
                 p -> ch[id] = newnode();
             p = p -> ch[id];
         }
         p -> mask |= <<number;
     }
     void build(){
         queue<node*> Q;
         root -> fail = root;
         for(int i = ;i < ;i++)
             if(root -> ch[i] == NULL)
                 root -> ch[i] = root;
             else{
                 Q.push(root -> ch[i]);
                 root -> ch[i] -> fail = root;
             }
         while(!Q.empty()){
             node *p = Q.front();Q.pop();
             for(int i = ;i < ;i++)
                 if(p -> ch[i] == NULL)
                     p -> ch[i] = p -> fail -> ch[i];
                 else{
                     Q.push(p -> ch[i]);
                     p -> ch[i] -> fail = p -> fail -> ch[i];
                     p -> ch[i] -> mask |= p -> ch[i] -> fail -> mask;
                 }
         }
     }
     int solve(int len,int number){
         memset(dp,,sizeof(dp));
         dp[][][] = true;
         for(int i = ;i <= len;i++){
             memset(dp[i&],,sizeof(dp[i&]));
             for(int j = ;j < top;j++){
                 node *cur = &stk[j];
                 for(int st = ;st < <<number;st++){
                     if(dp[(i+)&][j][st]){
                         for(int k = ;k < ;k++){
                             node *next = cur -> ch[k];
                             dp[i&][next - stk][st | next -> mask] = ;
                         }
                     }
                 }
             }
         }
         int ans = -inf;
         for(int i = ;i < top;i++)
             for(int j = ;j < <<number;j++)
                 if(dp[len&][i][j]){
                     ans = max(ans,score[j]);
                 }
         return ans;
     }
 };
 Trie AC;
 char s[N];
 int w[];
 int main(){
     hash['A'] = ;hash['C'] = ;hash['G'] = ;hash['T'] = ;
     int n,l;
     int cas = ;
     while(~scanf("%d%d",&n,&l)){
         AC.init();
         for(int i = ;i < n;i++){
             scanf("%s%d",s,&w[i]);
             AC.insert(s,i);
         }
         for(int i = ;i < <<n ;i++){
             score[i] = ;
             for(int j = ;j < n;j++)
                 if(i&(<<j))score[i] += w[j];
         }
         AC.build();
         int ans = AC.solve(l,n);
         //printf("Case %d\n",cas++);
         if(ans < )puts("No Rabbit after 2012!");
         else printf("%d\n",ans);
     }
     return ;
 }