poj 3691 DNA repair（AC自动机+dp）

DNA repair Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 5877   Accepted: 2760 Description Biologists finally invent techniques of repairing DNA that contains segments causing kinds of inherited diseases. For the sake of simplicity, a DNA is represented as a string containing characters 'A', 'G' , 'C' and 'T'. The repairing techniques are simply to change some characters to eliminate all segments causing diseases. For example, we can repair a DNA "AAGCAG" to "AGGCAC" to eliminate the initial causing disease segments "AAG", "AGC" and "CAG" by changing two characters. Note that the repaired DNA can still contain only characters 'A', 'G', 'C' and 'T'. You are to help the biologists to repair a DNA by changing least number of characters. Input The input consists of multiple test cases. Each test case starts with a line containing one integers  N (1 ≤  N ≤ 50), which is the number of DNA segments causing inherited diseases. The following  N lines gives  N non-empty strings of length not greater than 20 containing only characters in "AGCT", which are the DNA segments causing inherited disease. The last line of the test case is a non-empty string of length not greater than 1000 containing only characters in "AGCT", which is the DNA to be repaired. The last test case is followed by a line containing one zeros. Output For each test case, print a line containing the test case number( beginning with 1) followed by the number of characters which need to be changed. If it's impossible to repair the given DNA, print -1. Sample Input 2 AAA AAG AAAG 2 A TG TGAATG 4 A G C T AGT 0 Sample Output Case 1: 1 Case 2: 4 Case 3: -1 Source 2008 Asia Hefei Regional Contest Online by USTC

题意：

给定N个模式串(1 ≤ N ≤ 50) 最大长度为20，一个主串(长最大为1000)，允许涉及的字符为4个 {'A','T','G','C'}，求最少修改几个字符 使主串不包含所有模式串。

思路：

对模式串建立AC自动机，根据AC自动机来dp。

dp[i][j]表示到主串第i个字符时到达自动机上第j个节点时修改最少字符数。

枚举下一个字符为AGCT中的一个来转移，注意转移的时候不能包含模式串中的节点，于是要用一个数组来记录该节点结尾时是否包含了单词。

代码：

#include <cstdio>
#include <cstring>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;

const int INF=0x3f3f3f3f;
const int maxn=10010;
const int bsz=26;
typedef long long ll;
char txt[maxn],cc[]="AGCT";
bool vis[maxn];
int ans;

struct Trie
{
    bool have[maxn];  // 该节点结尾是否包含单词
    int ch[maxn][bsz],val[maxn],sz,cnt[maxn];  // ch存Trie val-节点对应的单词 cnt-节点结尾单词个数
    int f[maxn],last[maxn];//f-失配指针 last-后缀链接
    int newnode()
    {
        val[sz]=0; cnt[sz]=0; have[sz]=0;
        memset(ch[sz],-1,sizeof ch[sz]);
        return sz++;
    }
    void init()
    {
        sz=0;
        newnode();
    }
    int idx(char c)  // 取c的标号 具体看字符为什么
    {
        return c-'A';
    }
    void Insert(char *st,int id)
    {
        int u=0,n=strlen(st),c,i;
        for(i=0;i<n;i++)
        {
            c=idx(st[i]);
            if(ch[u][c]==-1)
                ch[u][c]=newnode();
            u=ch[u][c];
        }
        val[u]=id;
        cnt[u]++;
        have[u]=1;
    }
    void build()
    {
        int u=0,v,i;
        queue<int> q;
        f[0]=0;
        for(i=0;i<bsz;i++)
        {
            v=ch[u][i];
            if(v==-1) ch[u][i]=0;
            else
            {
                f[v]=0;
                q.push(v);
            }
        }
        while(!q.empty())
        {
            u=q.front();
            q.pop();
            last[u]=val[f[u]]?f[u]:last[f[u]];
            for(i=0;i<bsz;i++)
            {
                v=ch[u][i];
                if(v==-1) ch[u][i]=ch[f[u]][i]; // 将NULL变为有意义 沿着父亲失配指针走第一个有意义的节点
                else
                {
                    f[v]=ch[f[u]][i];
                    have[v]|=have[f[v]];
                    q.push(v);
                }
            }
        }
    }
    bool Find(char *st,int m,int id)
    {
        int n=strlen(st),i,u=0,c,p,flag=0;
        // vis-可标记哪些单词出现过 同样的单词只标记一个
        for(i=0;i<n;i++)
        {
            c=idx(st[i]);
            u=ch[u][c];
            p=val[u]?u:last[u];
            while(p)
            {
                vis[val[p]]=true;
                //if(val[p]){ ans+=cnt[p]; cnt[p]=0; }
                flag=1;
                p=last[p];
            }
        }
        if(!flag) return false;
        //可以将出现的单词标号输出
//        for(i=1;i<=m;i++)
//            if(vis[i])
//            {
//                vis[i]=0;
//                printf(" %d",i);
//            }
//        puts("");
        return true;
    }
} ac;
int dp[1005][1005];

void solve()
{
    int i,j,k,len=strlen(txt+1);
    int id,next;
    memset(dp,0x3f,sizeof(dp));
    dp[0][0]=0;
    for(i=0;i<len;i++)
    {
        for(j=0;j<ac.sz;j++)
        {
            if(dp[i][j]>=INF) continue ;
            for(k=0;k<4;k++)
            {
                id=ac.idx(cc[k]);
                next=ac.ch[j][id];
                if(ac.have[next]) continue ;
                if(cc[k]==txt[i+1])
                {
                    dp[i+1][next]=min(dp[i+1][next],dp[i][j]);
                }
                else
                {
                    dp[i+1][next]=min(dp[i+1][next],dp[i][j]+1);
                }
            }
        }
    }
    ans=INF;
    for(j=0;j<ac.sz;j++) ans=min(ans,dp[len][j]);
    if(ans>=INF) ans=-1;
}
int main()
{
    int i,j,n,ca=0;
    while(~scanf("%d",&n))
    {
        if(n==0) break ;
        ac.init();
        for(i=1;i<=n;i++)
        {
            scanf("%s",txt);
            ac.Insert(txt,i);
        }
        ac.build();
        scanf("%s",txt+1);
        solve();
        printf("Case %d: %d\n",++ca,ans);
    }
    return 0;
}