Match:DNA repair(POJ 3691)

　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　　基因修复

　　题目大意：给定一些坏串，再给你一个字符串，要你修复这个字符串（AGTC随便换），使之不含任何坏串，求修复所需要的最小步数。

　　这一题也是和之前的那个1625的思想是一样的，通过特殊的trie树找到所有的状态然后一个一个枚，具体状态转移的思想可以在1625那里看

　　当然了这一题不是像1625那样求总的组合数，这一题也是DP，求的是最小值，那么我们也是一样，统计从合法状态中转移到任何一个状态最小值即可。

　　状态转移方程dp[i+1][转移状态]=min(dp[i+1][转移状态],dp[i][当前状态]+s)（当转移状态对应的就是trie的节点，当节点对应的字符等于字符串当前位置的字符，则s为0，否则s为1。）

#include <iostream>
#include <algorithm>
#include <functional>
#include <string.h>
#define MAX 1010

using namespace std;

struct node
{
    int Num, If_End;
    struct node *Fail, *Next[4];
}*root, Mem_Pool[MAX], *Queue[2 * MAX];

static int sum_node, Hash_Table[256], dp[MAX][MAX];
static char str[MAX], DNA[4] = { 'A', 'G', 'C', 'T' };

struct node *create_new_node();
int find_min(const int, const int);
void put_DNA_into_hash(void);
void insert(struct node *);
void build_ac_automation(struct node *);

int main(void)
{
    int Disease_Segement_Sum, str_length, case_sum = 1;

    put_DNA_into_hash();
    while (~scanf("%d", &Disease_Segement_Sum))
    {
        if (Disease_Segement_Sum == 0)
            break;
        sum_node = 0;
        node *root = create_new_node();
        getchar();
        
        for (int i = 0; i < Disease_Segement_Sum; i++)
            insert(root);
        build_ac_automation(root);

        gets(str);
        str_length = strlen(str);

        for (int i = 0; i < str_length; i++)
        {
            fill(dp[i + 1], dp[i + 1] + sum_node, MAX + 1);
            for (int j = 0; j < sum_node; j++)
            {
                if (Mem_Pool[j].If_End)
                    continue;
                for (int k = 0; k < 4; k++)
                {
                    int id = Mem_Pool[j].Next[k]->Num;
                    if (Mem_Pool[j].Next[k]->If_End)
                        continue;
                    else if (Hash_Table[str[i]] == k)
                        dp[i + 1][id] = find_min(dp[i + 1][id], dp[i][j]);
                    else
                        dp[i + 1][id] = find_min(dp[i + 1][id], dp[i][j] + 1);
                }
            }
        }
        int ans = MAX + 1;
        for (int i = 0; i < sum_node; i++)
            ans = find_min(ans, dp[str_length][i]);
        if (ans != MAX + 1)
            printf("Case %d: %d
", case_sum++, ans);
        else
            printf("Case %d: -1
",case_sum++);
    }
    return EXIT_SUCCESS;
}

int find_min(const int x, const int y)
{
    return x < y ? x : y;
}

struct node *create_new_node(void)
{
    node *tmp = &Mem_Pool[sum_node];
    tmp->Fail = NULL;
    tmp->If_End = 0;
    memset(tmp->Next, 0, sizeof(struct node *) * 4);
    tmp->Num = sum_node++;
    return tmp;
}

void put_DNA_into_hash(void)
{
    for (int i = 0; i<4; i++)
        Hash_Table[DNA[i]] = i;
}

void insert(struct node *root)
{
    node *ptr = root;
    gets(str);

    for (int i = 0; str[i] != ''; i++)
    {
        int id = Hash_Table[str[i]];
        if (ptr->Next[id] == NULL)
            ptr->Next[id] = create_new_node();
        ptr = ptr->Next[id];
    }
    ptr->If_End = 1;
}

void build_ac_automation(struct node *root)
{
    int head = 0, tail = 0;
    root->Fail = NULL;
    Queue[tail++] = root;

    while (head != tail)
    {
        node *out = Queue[head++];
        for (int i = 0; i < 4; i++)
        {
            if (out->Next[i] != NULL)
            {
                if (out == root)
                    out->Next[i]->Fail = root;
                else
                {
                    out->Next[i]->Fail = out->Fail->Next[i];
                    if (out->Fail->Next[i]->If_End)
                        out->Next[i]->If_End = 1;
                }
                Queue[tail++] = out->Next[i];
            }
            else if (out == root)
                out->Next[i] = root;
            else
                out->Next[i] = out->Fail->Next[i];
        }
    }
}