hdu2457 Trie图+dp

hdu2457

给定n个模式串， 和一个文本串

问如果修改最少的字符串使得文本串不包含模式串， 

输出最少的次数，如果不能修改成功，则输出-1

dp[i][j] 表示长度为i的字符串， 到达状态j（Trie图中的结点）所需要修改的最少次数

那么dp[0->n][0->size] = INF ,  dp[0][root] = 0,  n代表字符串长度， size代表状态数

那么答案就是  min{dp[n][size]}

我们根据模式串所建的Trie图， 进行模拟构造不包含模式串的字符串

从第一个字符串开始构造，依次递增，在构造此字符的同时，比较是否和输入串的该字符串相等，

如果相等，则表示该位置的字符不需要改变， 如果不同，则表示该位置的字符需要改变

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <algorithm>
#include <iostream>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <string>
#include <math.h>
using namespace std;
#pragma warning(disable:4996)
typedef long long LL;                   
const int INF = 1<<30;
/*

*/
struct Node
{
    int fail, next[4];
    bool isWord;
    void init()
    {
        fail = -1;
        isWord = false;
        for (int i = 0; i < 4; ++i)
            next[i] = -1;

    }
}Trie[1000 + 10];
int size;
char str[1000 + 10];
int dp[1000 + 10][1000 + 10];
int getCode(char ch)
{
    if (ch == 'A')
        return 0;
    if (ch == 'G')
        return 1;
    if (ch == 'C')
        return 2;
    return 3;
}
void insert(int root, char str[])
{
    int cur = root;
    for (int i = 0; str[i]; ++i)
    {
        int idx = getCode(str[i]);
        if (Trie[cur].next[idx] == -1)
        {
            Trie[size].init();
            Trie[cur].next[idx] = size++;
        }
        cur = Trie[cur].next[idx];
    }
    Trie[cur].isWord = true;
}
void makeFail(int root)
{
    queue<int> q;
    int cur;
    for (int i = 0; i < 4; ++i)
    if (Trie[root].next[i] == -1)
        Trie[root].next[i] = root;
    else
    {
        Trie[Trie[root].next[i]].fail = root;
        q.push(Trie[root].next[i]);
    }
    while (!q.empty())
    {
        cur = q.front();
        q.pop();
        for (int i = 0; i < 4; ++i)
        {
            if (Trie[Trie[cur].fail].isWord)
                Trie[cur].isWord = true;
            if (Trie[cur].next[i] == -1)
                Trie[cur].next[i] = Trie[Trie[cur].fail].next[i];
            else
            {
                Trie[Trie[cur].next[i]].fail = Trie[Trie[cur].fail].next[i];
                q.push(Trie[cur].next[i]);
            }
        }
    }
}

//dp[i][j] 表示长度为i的字符串到达状态j，所要修改的次数，  如果状态为危险状态，那么肯定是INF
int solve(int root, char *str)
{
    int n = strlen(str);
    for (int i = 0; i <= n; ++i)
    for (int j = 0; j < size; ++j)
        dp[i][j] = INF;

    dp[0][root] = 0;
    for (int i = 0; i < n; ++i)
    for (int j = 0; j < size; ++j)
    if (dp[i][j] < INF)
    {
        for (int k = 0; k < 4; ++k)
        {
            int next = Trie[j].next[k];
            if (Trie[next].isWord) continue;
            int tmp;
            if (k == getCode(str[i]))
                tmp = dp[i][j];//如果构造出的字符和输入字符相同，就不需要改变该位置的字符串
            else
                tmp = dp[i][j] + 1;//否则，要改变该位置的字符串
            dp[i + 1][next] = min(dp[i + 1][next], tmp);
        }
    }
    int ans = INF;
    for (int j = 0; j < size; ++j)
        ans = min(ans, dp[n][j]);
    if (ans == INF) ans = -1;
    return ans;
}

int main()
{
    int n, k = 1;
    char segment[20+10];
    while(scanf("%d", &n), n)
    {
        Trie[0].init();
        Trie[0].fail = 0;
        size = 1;
        for (int i = 0; i < n; ++i)
        {
            scanf("%s", segment);
            insert(0, segment);
        }
        makeFail(0);
        scanf("%s", str);
        printf("Case %d: %d
", k, solve(0, str));
        k++;

    }
    return 0;
}