HDU 2457 DNA repair AC 로봇 + 동적 계획

제목 대의:
바로 현재 n(1<=n<=50)개의 DNA 서열이 질병이 있는데, 현재 하나의 DNA 서열(길이가 1000을 넘지 않음)이 있는데, 그 중의 문자를 교체해야 한다(A, C, G, T로만 바꿀 수 있다). 이 DNA 서열은 질병 서열을 포함하지 않는다. 최소한 몇 글자를 교체해야 하는지 묻는다. 이런 해가 존재하지 않으면 출력-1
대략적인 사고방식:
간단한 AC 자동기 + 동적 기획으로 어려운 점이 없어요...
상태 이동 방정식 설명은 코드를 보십시오.
Result  :  Accepted     Memory  :  4328 KB     Time  :  62 ms

/*
 * Author: Gatevin
 * Created Time:  2014/11/22 15:00:55
 * File Name: Kagome.cpp
 */
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-8);
typedef long long lint;

int n;
const int inf = 9999999;
int dp[1010][1010];
/*
 * dp[i][j]     i Trie    j                        
 *         dp[i][j]   
 * dp[i + 1][next[j][t]] = min(dp[i + 1][next[j][t]], dp[i][j]) (M[s[i]] == t) M[s[i]]   s[i]   
 * dp[i + 1][next[j][t]] = min(dp[i + 1][next[j][t]], dp[i][j] + 1) (M[s[i]] != t)
 */


map <char, int> M;
char s[1010];
struct Trie
{
    int next[1010][4], fail[1010];
    bool end[1010];
    int L, root;
    int newnode()
    {
        for(int i = 0; i < 4; i++)
            next[L][i] = -1;
        end[L++] = 0;
        return L - 1;
    }
    void init()
    {
        L = 0;
        root = newnode();
        return;
    }
    void insert(char *s)
    {
        int now = root;
        for(; *s; s++)
        {
            if(next[now][M[*s]] == -1)
                next[now][M[*s]] = newnode();
            now = next[now][M[*s]];
        }
        end[now] = 1;
        return;
    }
    void build()
    {
        queue <int> Q;
        fail[root] = root;
        Q.push(root);
        while(!Q.empty())
        {
            int now = Q.front();
            Q.pop();
            if(end[fail[now]]) end[now] = 1;
            for(int i = 0; i < 4; i++)
                if(next[now][i] == -1)
                    next[now][i] = now == root ? root : next[fail[now]][i];
                else
                {
                    fail[next[now][i]] = now == root ? root : next[fail[now]][i];
                    Q.push(next[now][i]);
                }
        }
        return;
    }
    void solve(int cas)
    {
        int len = strlen(s);
        for(int i = 0; i <= len; i++)
            for(int j = 0; j < L; j++)
                dp[i][j] = inf;
        dp[0][0] = 0;
        for(int i = 0; i < len; i++)
            for(int j = 0; j < L; j++)
            {
                if(dp[i][j] == inf) continue;
                for(int k = 0; k < 4; k++)
                {
                    if(!end[next[j][k]])//                 
                    {
                        if(k == M[s[i]])//        
                            dp[i + 1][next[j][k]] = min(dp[i + 1][next[j][k]], dp[i][j]);
                        else
                            dp[i + 1][next[j][k]] = min(dp[i + 1][next[j][k]], dp[i][j] + 1);
                    }
                }
            }
        int ans = inf;
        for(int i = 0; i < L; i++)
            ans = min(ans, dp[len][i]);
        printf("Case %d: %d
", cas, ans == inf ? -1 : ans);
        return;
    }
};

Trie AC;

int main()
{
    char ts[22];
    int cas = 0;
    M['A'] = 0; M['C'] = 1; M['G'] = 2; M['T'] = 3;
    while(scanf("%d", &n), n)
    {
        cas++;
        AC.init();
        while(n--)
        {
            scanf("%s", ts);
            AC.insert(ts);
        }
        scanf("%s", s);
        AC.build();
        AC.solve(cas);
    }
    return 0;
}