POJ 2778 DNA Sequence（AC自动机+矩阵快速幂）

http://poj.org/problem?id=2778

题意：
给出一些病毒字符串，只由A,T,C,G组成，现在要用着4个字符组成长度为n的字符串，且字符串中不可以包含任一病毒字符串，问共有多少种字符串。

思路：

回想一下离散数学中所学的邻接矩阵

而AC自动机的状态图就是一个有向图，我们只需要根据这个有向图建立邻接矩阵即可，因为不可以包含病毒串，所以只需要判断是否是字符串结尾，如果不是就说明可以连接起来。

注意在fail转移的时候传递字符串结尾标记。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<vector>
#include<stack>
#include<queue>
#include<cmath>
#include<map>
#include<set>
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int maxn=10000+5;
const int mod=100000;

int n, m, num;
char s[20];

struct Trie
{
    int son[10];
    int cnt;
    int fail;
}t[150];


struct Matrix
{
    ll mat[200][200], n;
    Matrix(){}
    Matrix(int _n)
    {
        n=_n;
        for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            mat[i][j]=0;
    }
    Matrix operator*(const Matrix& b) const
    {
        Matrix c=Matrix(n);
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                for(int k=0;k<n;k++)
                {
                    c.mat[i][j]=(c.mat[i][j]+mat[i][k]*b.mat[k][j])%mod;
                }
            }
        }
        return c;
    }
};

void init(int x)
{
    t[x].fail=0;
    t[x].cnt=0;
    memset(t[x].son,0,sizeof(t[x].son));
}

int getch(char ch)
{
    if(ch=='A')   return 1;
    if(ch=='T')   return 2;
    if(ch=='C')   return 3;
    if(ch=='G')   return 4;
}

void trie(char *s)
{
    int n=strlen(s);
    int x=0;
    for(int i=0;i<n;i++)
    {
        int c=getch(s[i]);
        if(!t[x].son[c])
        {
            num++;
            init(num);
            t[x].son[c]=num;
        }
        x=t[x].son[c];
    }
    t[x].cnt=1;
}

void buildAC()
{
    queue<int> Q;
    for(int i=1;i<=4;i++)  if(t[0].son[i])  Q.push(t[0].son[i]);
    while(!Q.empty())
    {
        int x=Q.front(); Q.pop();
        int fail=t[x].fail;
        for(int i=1;i<=4;i++)
        {

            int y=t[x].son[i];
            if(y)
            {
                t[y].fail=t[fail].son[i];
                t[y].cnt|=t[t[fail].son[i]].cnt;  //这儿很重要，这个标记需要传递
                Q.push(y);
            }
            else t[x].son[i]=t[fail].son[i];
        }
    }
}

Matrix getMatrix()
{
    Matrix c=Matrix(num+1);
    for(int i=0;i<=num;i++)
    {
        for(int j=1;j<=4;j++)
        {
            if(t[t[i].son[j]].cnt==0)  c.mat[i][t[i].son[j]]++;
        }
    }
    return c;
}


void q_pow(Matrix base, int n)
{
    Matrix ans=Matrix(base.n);
    for(int i=0;i<ans.n;i++)   ans.mat[i][i]=1;
    while(n)
    {
        if(n&1)  ans=ans*base;
        base=base*base;
        n>>=1;
    }
    int res=0;
    for(int i=0;i<ans.n;i++)
        res=(res+ans.mat[0][i])%mod;
    printf("%d
",res);
}

int main()
{
    //freopen("in.txt","r",stdin);
    while(~scanf("%d%d",&m,&n))
    {
        init(0);
        num=0;
        for(int i=1;i<=m;i++)
        {
            scanf("%s",s);
            trie(s);
        }
        buildAC();
        Matrix c=getMatrix();
        q_pow(c,n);
    }
    return 0;
}