POJ 3691 DNA repair ( Trie图 && DP )

题意 : 给出 n 个病毒串，最后再给出一个主串，问你最少改变主串中的多少个单词才能使得主串中不包含任何一个病毒串

分析 : 做多了AC自动机的题，就会发现这些题有些都是很套路的题目。在构建 Trie 图的时候给病毒串末尾打上标记，最后定义DP[i][j] = 长度为 i 的串在 j 这个状态节点最少改变数使得其不包含病毒串，则状态转移方程

if(Trie[k]不是被标记的病毒节点) DP[i+1][j] = min( DP[i+1][j], DP[i][k] + (mp[S[i]] != k) )

k 为 j 节点的四个下一状态，转到"ATGC"其中一个，而mp[]作用是把"ATGC"转为0、1、2、3

DP的初始状态为 DP[0][0] = 0，DP[0~len][0~节点数] = INF

具体的看代码即可

#include<queue>
#include<stdio.h>
#include<string.h>
using namespace std;

;
;
const int INF = 0x3f3f3f3f;
];

struct Aho{
    struct StateTable{
        int Next[Letter];
        int fail, flag;
    }Node[Max_Tot];
    int Size;
    queue<int> que;

    inline void init(){
        while(!que.empty()) que.pop();
        memset(Node[].Next, , ].Next));
        Node[].fail = Node[].flag = ;
        Size = ;
    }

    inline void insert(char *s){
        ;
        ; s[i]; i++){
            int idx = mp[s[i]];
            if(!Node[now].Next[idx]){
                memset(Node[Size].Next, , sizeof(Node[Size].Next));
                Node[Size].fail = Node[Size].flag = ;
                Node[now].Next[idx] = Size++;
            }
            now = Node[now].Next[idx];
        }
        Node[now].flag = ;
    }

    inline void BuildFail(){
        Node[].fail = ;
        ; i<Letter; i++){
            ].Next[i]){
                Node[Node[].Next[i]].fail = ;
                que.push(Node[].Next[i]);
            }].Next[i] = ;///必定指向根节点
        }
        while(!que.empty()){
            int top = que.front(); que.pop();
            ;
            ; i<Letter; i++){
                int &v = Node[top].Next[i];
                if(v){
                    que.push(v);
                    Node[v].fail = Node[Node[top].fail].Next[i];
                }else v = Node[Node[top].fail].Next[i];
            }
        }
    }
}ac;
];
][];

int main(void)
{
    mp[,
    mp[,
    mp[,
    mp[;
    ;
    while(~scanf("%d", &n) && n){
        ac.init();
        ; i<n; i++){
            scanf("%s", S);
            ac.insert(S);
        }
        ac.BuildFail();
        scanf("%s", S);
        int len = strlen(S);

        ; i<=len; i++)
            ; j<=ac.Size; j++)
                dp[i][j] = ;

        dp[][] = ;

        ; i<len; i++){
            ; j<ac.Size; j++){
                ){
                    ; k<; k++){
                        ;
                        int newj = ac.Node[j].Next[k];
                        if(!ac.Node[newj].flag){
                            dp[newi][newj] = min(dp[newi][newj],
                                                 dp[i][j] + (k != mp[S[i]]) );
                        }
                    }
                }
            }
        }

        ;
        ; i<ac.Size; i++)
            ans = min(ans, dp[len][i]);

        printf("Case %d: ", Case++);
        ) printf("%d\n", ans);
        else puts("-1");
    }
    ;
}