hdu 2457 AC自动机DP

题意： 给出了一些病毒串的基因， 又给出了一个基因串，问至少修改多少个基因串中的字符可以不含病毒串。

思路： 这道题是用AC自动机搞的， 好久没写AC自动机了。

这道题的主要思路是构造基因串， 保证构造的基因串不含病毒串， 并且与给出的串相比修改的最少。

1、首先利用病毒串构造自动机， 但是需要注意两点，一是如果fall的结尾标记是病毒串的结尾，那么当前位置也要标记是病毒串的结尾。 如果next为-1， 那么一定要赋一个值，一般赋为fall的next，如果是root的话那就直接是root就行。将每个节点看成是一个状态。

2、进行DP， 对于初始化为INF的ＤＰ，　最好加一个continue， DP的过程其实是构造串的过程。

dp[i][j]表示构造到第i个字符的时候在j状态时需要修改的最小值。

 x = s[j].next[k]; x必须是可达状态
dp[i+1][x] = min( dp[i+1][x], dp[i][j] + (a[i+1]!=k) )；

AC代码：

#include<iostream>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;
const int N = 2010, INF = 1<<29;
struct node
{
    int f;
    int next[4];
    int fall;
    void init()
    {
        memset(next,-1,sizeof(next));
        fall = -1;
        f = 0;
    }
} s[N];
int p;
char a[N];

inline void preprocess()
{
    s[p=0].init();
    s[0].fall = -1;
}

int get(char a)
 {
     if(a == 'A') return 0;
     if(a == 'C') return 1;
     if(a == 'G') return 2;
     return 3;
 }

void insert(char *a)
{
    int ind = 0;
    int i;
    for(i=0; a[i]; ++i)
    {
        int x=get(a[i]);
        if(s[ind].next[x]==-1)
        {
            s[++p].init();
            s[ind].next[x]=p;
        }
        ind = s[ind].next[x];
    }
    ++s[ind].f;
}

void build_ac()
{
    int root=0;
    s[root].fall=-1;
    queue<int> q;
    q.push(root);
    while (!q.empty())
    {
        int t=q.front();
        q.pop();
        int i;
        for (i=0; i<4; ++i)
        {
            int ind = s[t].next[i];
            if(ind != -1)
             {
                if (t == root)
                 {
                    s[ind].fall = root;
                 }
                else
                 {
                    int p = s[t].fall;
                    while (p != -1)
                     {
                        if (s[p].next[i] != -1)
                        {
                            s[ind].fall = s[p].next[i];
                            int x = s[p].next[i];
                            if(s[x].f)
                             s[ind].f = 1;
                            break;
                        }
                        p = s[p].fall;
                     }

                    if (p == -1)
                     {
                        s[ind].fall = root;
                     }
                 }
                q.push(ind);
             }
            else
             {
                 if(t == 0)
                  s[t].next[i] = 0;
                 else
                  {
                      int x = s[t].fall;
                      s[t].next[i] = s[x].next[i];
                  }
             }
        }
    }
}


int n, dp[N][N];

int DP()
 {
     for(int i=0; i<=n; i++)
      {
          for(int j=0; j<=p; j++)
           dp[i][j] = INF;
      }
    dp[0][0] = 0;
    for(int i=0; i<n; i++)
     {
         for(int j=0; j<=p; j++)
          {
              if(dp[i][j] == INF) continue;
              for(int k=0; k<4; k++)
               {
                   int x = s[j].next[k];
                   if(s[x].f) continue;
                   dp[i+1][x] = min(
                            dp[i+1][x], dp[i][j] + (a[i+1]!=k) );
               }
          }
     }
    int ans = INF;
    for(int i=0; i<=p; i++)
     ans = min(ans, dp[n][i]);
    if(ans == INF) return -1;
    return ans;
 }

int main()
{
    int test = 0;
    while(scanf("%d", &n) != EOF && n)
    {
        test++;
        preprocess();
        for(int i=0; i<n; i++)
        {
           scanf("%s",a);
           insert(a);
        }
        
        scanf("%s",a+1);
        n = strlen(a+1);
        for(int i=1; i<=n; i++)
         a[i] = get(a[i]);
        build_ac();
        printf("Case %d: %d\n", test, DP());
    }
    return 0;
}