AC自动机+矩阵快速幂 POJ 2778

题意：有m种DNA序列是有疾病的，问有多少种长度为n的DNA序列不包含任何一种有疾病的DNA序列。（仅含A,T,C,G四个字符）

首先我们需要知道

给定一个有向图，问从A点恰好走k步（允许重复经过边）到达B点的方案数mod p的值

把给定的图转为邻接矩阵，即A(i,j)=1当且仅当存在一条边i->j。令C=A*A，那么C(i,j)=ΣA(i,k)*A(k,j)，实际上就等于从点i到点j恰好经过2条边的路径数（枚举k为中转点）。类似地，C*A的第i行第j列就表示从i到j经过3条边的路径数。同理，如果要求经过k步的路径数，我们只需要求出A^k即可。

其次

对于有疾病的序列，我们可以标记下来最后一个节点，需要注意的是，对于一个节点，如果其fail指针指向的是标记节点，那么这个节点也要被标记，因为fail指向的序列一定是当前序列的后缀。标记完后，开始建邻接矩阵，凡是以标记节点作为结尾的边权值都为0（不允许到达）。

最后 

对于得到的邻接矩阵跑矩阵快速幂然后统计从根节点到每一个节点的种数之和。

#include <cmath>
#include <queue>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#define LL long long
#define INF 0x3f3f3f3f
using namespace std;
const int maxn = 15;
const int mod = 1e5;
int m,k;char str[15];
struct matrix{LL a[111][111];}X;
int ch(char c)
{
    if(c=='A') return 0;if(c=='C') return 1;
    if(c=='G') return 2;if(c=='T') return 3;
}
struct Trie
{
    int next[111][4],fail[111],end[111];
    int root,L;
    int newnode()
    {
        for(int i = 0;i < 4;i++)
            next[L][i] = -1;
        end[L++] = 0;
        return L-1;
    }
    void init(){L = 0;root = newnode();}
    void insert(char buf[])
    {
        int len = strlen(buf);
        int now = root;
        for(int i = 0;i < len;i++)
        {
            if(next[now][ch(buf[i])] == -1)
                next[now][ch(buf[i])] = newnode();
            now = next[now][ch(buf[i])];
        }
        end[now]=1;
    }
    void build()
    {
        queue<int>Q;
        fail[root] = root;
        for(int i = 0;i < 4;i++)
            if(next[root][i] == -1)
                next[root][i] = root;
            else
            {
                fail[next[root][i]] = root;
                Q.push(next[root][i]);
            }
        while( !Q.empty() )
        {
            int now = Q.front();
            Q.pop();
            if(end[fail[now]])
                end[now]=1;
            for(int i = 0;i < 4;i++)
                if(next[now][i] == -1)
                    next[now][i] = next[fail[now]][i];
                else
                {
                    fail[next[now][i]]=next[fail[now]][i];
                    Q.push(next[now][i]);
                }
        }
    }
}ac;
matrix multi(matrix A,matrix B)
{
    matrix C;int n = ac.L;
    memset(C.a,0,sizeof(C.a));
    int i,j,k;
    for(i=0;i<n;i++)
        for(j=0;j<n;j++)
        {
            for(k=0;k<n;k++)
                C.a[i][j] += A.a[i][k]*B.a[k][j];
            C.a[i][j] %= mod;
        }
    return C;
}
matrix quickly(matrix A,int k)
{
    matrix ans;
    memset(ans.a,0,sizeof(ans.a));
    for(int i=0;i<ac.L;i++)
        ans.a[i][i]=1;
    while(k)
    {
        if(k & 1) ans = multi(A,ans);
        A = multi(A,A);
        k>>=1;
    }
    return ans;
}
matrix getmatrix(matrix A)
{
    memset(A.a,0,sizeof(A));
    for(int i=0;i<ac.L;i++)
        for(int j=0;j<4;j++)
            if(!ac.end[ac.next[i][j]])
                A.a[i][ac.next[i][j]]++;
    return A;
}
int main()
{
    int i;
    while(~scanf("%d%d",&m,&k))
    {
        ac.init();
        for(i=1;i<=m;i++)
        {
            scanf("%s",str);
            ac.insert(str);
        }
        ac.build();
        X = getmatrix(X);
        X = quickly(X,k);
        LL ans = 0;
        for(i=0;i<ac.L;i++) ans = (ans + X.a[0][i])%mod;
        printf("%lld\n",ans);
    }
    return 0;
}