HDU 3341 状态压缩DP+AC自动机

题目大意：

调整基因的顺序，希望使得最后得到的基因包含有最多的匹配串基因，使得所能达到的智商最高

这里很明显要用状态压缩当前AC自动机上点使用了基因的情况所能达到的最优状态

我最开始对于状态的保存是，针对基因的个数转化为最小的二进制个数保存，但是浪费了很多二进制位，比如8 -> 1000，那么之后的1001,1010...1111都没用到

就MLE了

然后自己只能在压缩

比如数量为2 ， 3 ， 4 ， 5

那么jz[0] = 1 , jz[1] = 2+1 , jz[2] = 2*1+3*3+1 , jz[3] = 2*1+3*3+4*12+1

那么可以根据这种进制进行解码转码了

那么状态数就能通过解码转码轻松获得了

可能自己写的比较挫吧，跑c++跑不过，g++倒是完全没问题

 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <cmath>
 #include <queue>
 using namespace std;
 #define LL long long
 #define clr(x) memset(x , 0 , sizeof(x))
 #define MAX_SIZE 502
 #define CHAR_SIZE 4
 const int MAX_STATE = ;
 int n;
 char str[];

 int Hash(char c){
     if(c=='A') return ;
     else if(c == 'C') return ;
     else if(c=='G') return ;
     else return ;
 }

 struct AC_Machine{
     int sz , ch[MAX_SIZE][CHAR_SIZE] , fail[MAX_SIZE], val[MAX_SIZE] , gene[MAX_SIZE];
     void init(){
         sz = ;
         clr(ch[]) , clr(val);
         gene[] = ;
     }

     void insert(char *s){
         int n=strlen(s) , u=;
         for(int i= ; i<n ; i++){
             int c = Hash(s[i]);
             if(!ch[u][c]){
                 clr(ch[sz]);
                 val[sz] = gene[sz] = ;
                 ch[u][c] = sz++;
             }
             u = ch[u][c];
         }
         gene[u] ++;
         val[u] = ;
     }

     void get_fail(){
         queue<int> Q;
         fail[] = ;
         for(int c= ; c<CHAR_SIZE ; c++){
             int u = ch[][c];
             if(u) {Q.push(u);fail[u]=;}
         }
         while(!Q.empty()){
             int r = Q.front();
             val[r] |= val[fail[r]];
             Q.pop();
             for(int c= ; c<CHAR_SIZE ; c++){
                 int u = ch[r][c];
                 if(!u){ch[r][c]=ch[fail[r]][c] ; continue;}
                 fail[u] = ch[fail[r]][c];
                 Q.push(u);
             }
         }
     }
 }ac;

 int dp[MAX_SIZE][MAX_STATE];
 int cnt[] , jz[];
 int code[] , save[];
 void decode(int state)
 {
     for(int i= ; i>= ; i--){
         code[i] = state/jz[i];
         state -= code[i]*jz[i];
     }
 }

 int encode(int *code)
 {
     int ret = ;
     for(int i= ; i>= ; i--) ret+=code[i]*jz[i];
     return ret;
 }

 void DP()
 {
     int all = encode(cnt);
     for(int i= ; i<=all ; i++)
         for(int j= ; j<ac.sz ; j++) dp[j][i] = -;
     dp[][] = ;
     for(int i= ; i<=all ; i++){
         for(int j= ; j<ac.sz ; j++){
             if(dp[j][i]<) continue;
             decode(i);
             for(int k= ; k< ; k++){
                 if(code[k]>=cnt[k]) continue;
                 int v = ac.ch[j][k];
                 int tmp = v , num=;
                 while(tmp&&ac.val[tmp]){
                     if(ac.gene[tmp]) num+=ac.gene[tmp];
                     tmp = ac.fail[tmp];
                 }
                 code[k]++;
                 int newst = encode(code);
                 code[k]--;
                 dp[v][newst] = max(dp[j][i]+num , dp[v][newst]);
             }
         }
     }
 }

 void solve()
 {
     int  len = strlen(str);
     memset(cnt ,  , sizeof(cnt));
     for(int i= ; i<len ; i++) cnt[Hash(str[i])]++;
     jz[] =  , jz[] = cnt[]+ , jz[] = +cnt[]+cnt[]*jz[] , jz[] = cnt[]*jz[]+jz[];
     DP();
 }

 int main()
 {
    // freopen("in.txt" , "r" , stdin);
     int cas = ;
     while(scanf("%d" , &n) , n)
     {
         ac.init();
         for(int i= ; i<n ; i++){
             scanf("%s" , str);
             ac.insert(str);
         }
         ac.get_fail();
         scanf("%s" , str);
         solve();
         int all = encode(cnt);
         int ret = -;
         for(int i= ; i<ac.sz ; i++) ret = max(ret , dp[i][all]);
         printf("Case %d: %d\n" , ++cas , ret);
     }
     return ;
 }