（AC自动机/矩阵快速幂）poj 2778 DNA Sequence

---恢复内容开始---

It's well known that DNA Sequence is a sequence only contains A, C, T and G, and it's very useful to analyze a segment of DNA Sequence，For example, if a animal's DNA sequence contains segment ATC then it may mean that the animal may have a genetic disease. Until now scientists have found several those segments, the problem is how many kinds of DNA sequences of a species don't contain those segments. 

Suppose that DNA sequences of a species is a sequence that consist of A, C, T and G，and the length of sequences is a given integer n. 

Input

First line contains two integer m (0 <= m <= 10), n (1 <= n <=2000000000). Here, m is the number of genetic disease segment, and n is the length of sequences. 

Next m lines each line contain a DNA genetic disease segment, and length of these segments is not larger than 10. 

Output

An integer, the number of DNA sequences, mod 100000.

Sample Input

4 3
AT
AC
AG
AA

Sample Output

36

非常经典的题目。

注意到将给定的字符串建立AC自动机以后，点数最多也只有100，其中一些点为坏点（即对匹配串在AC自动机上匹配时不能到的点，若到了即含有不应该出现的字符串）。

考虑建立矩阵，第i行第j列表示从编号为i的节点下一步走到编号为j的节点的路径数。因为不能到坏点，也就更不能从坏点出发，将坏点对应的行列全部置为0。

由此得到的矩阵n次幂后第一行的值之和即为符合题意的个数。

整个过程中几个需要注意的细节：

1、原点连出的边如果连向的节点不存在，则将该边连回原点

2、某位置如果后缀是病毒，则该节点也为坏节点

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <string>
#include <cstring>
#include <stack>
#include <queue>
#include <cmath>
#include <ctime>
#include <bitset>
#include <utility>
#include <assert.h>
using namespace std;
#define rank rankk
#define mp make_pair
#define pb push_back
#define xo(a,b) ((b)&1?(a):0)
#define tm tmp
//#define LL ll
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef long long ll;
typedef pair<ll,int> pli;
typedef pair<ll,ll> pll;
const int INF=0x3f3f3f3f;
const ll INFF=0x3f3f3f3f3f3f3f3fll;
const int MAX=1e6+5;
//const ll MAXN=2e8;
//const int MAX_N=MAX;
const int MOD=1e5;
//const long double pi=acos(-1.0);
const long double eps=1e-9;
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
template<typename T>inline T abs(T a) {return a>0?a:-a;}
template<class T> inline
void read(T& num) {
    bool start=false,neg=false;
    char c;
    num=0;
    while((c=getchar())!=EOF) {
        if(c=='-') start=neg=true;
        else if(c>='0' && c<='9') {
            start=true;
            num=num*10+c-'0';
        } else if(start) break;
    }
    if(neg) num=-num;
}
inline ll powMM(ll a,ll b,ll M){
    ll ret=1;
    a%=M;
//    b%=M;
    while (b){
        if (b&1) ret=ret*a%M;
        b>>=1;
        a=a*a%M;
    }
    return ret;
}
void open()
{
//    freopen("1009.in","r",stdin);
    freopen("out.txt","w",stdout);
}
//int类型matrix模版
const int m_num=105;//矩阵的大小
inline void add(int &a,int b)//保证a、b已全取过一次MOD（可以为负）
{
    a=(a+b+MOD)%MOD;if(a<0)a+=MOD;
}
struct matrix
{
    int e[m_num][m_num];
    int row,col;
    matrix(){}
    matrix(int _r,int _c):row(_r),col(_c){memset(e,0,sizeof(e));}
    matrix operator * (const matrix &tem)const
    {
        matrix ret=matrix(row,tem.col);//新形成的矩阵规模为 左行右列
        for(int i=1;i<=ret.row;i++)
            for(int j=1;j<=ret.col;j++)
                for(int k=1;k<=col;k++)
                    add(ret.e[i][j],1LL*e[i][k]*tem.e[k][j]%MOD);
        return ret;
    }
    matrix operator + (const matrix &tem)const
    {
        matrix ret=matrix(row,col);
        for(int i=1;i<=row;i++)
            for(int j=1;j<=col;j++)add(ret.e[i][j],(e[i][j]+tem.e[i][j])%MOD);
        return ret;
    }
    void getE()//化为单位阵
    {
        for(int i=1;i<=row;i++)
            for(int j=1;j<=col;j++)e[i][j]=(i==j?1:0);
    }
};
matrix m_qpow(matrix tem,int x)//矩阵快速幂
{
    matrix ret=matrix(tem.row,tem.row);
    ret.getE();
    while(x)
    {
        if(x&1)ret=ret*tem;
        x>>=1;tem=tem*tem;
    }
    return ret;
}



const int SIGMA_SIZE=4;
const int MAXNODE=110;
/*
    由于失配过程比较复杂，要反复沿着失配边走，
    在实践中常常会把下述自动机改造一下，把所有不存在的边“补上”
    即把计算失配函数中的语句if(!u)continue;改成
    if(!u){ch[r][c]=ch[f[r]][c];continue;}
    这样，就完全不需要失配函数，而是对所有转移一视同仁
    即find函数中的while(j&&!ch[j][c])j=f[j] 可以直接删除

*/
struct AhoCorasickAutomata
{
    int ch[MAXNODE][SIGMA_SIZE];//Trie树
    int f[MAXNODE];//fail函数
    int val[MAXNODE];//每个字符串的结尾结点都有非0的val
    int num;//trie树编号（亦为包含根结点的当前size）
    //初始化
    void init()
    {
        num=1;
        memset(ch[0],-1,sizeof(ch[0]));
        val[0]=0;
    }
    //返回字符对应编号
    int idx(char c)
    {
        if(c=='A')return 0;
        else if(c=='T')return 1;
        else if(c=='C')return 2;
        else if(c=='G')return 3;
    }
    //插入权值为v的字符串
    void insert(char *s,int v)
    {
        int u=0,n=strlen(s);
        for(int i=0;i<n;i++)
        {
            int c=idx(s[i]);
            if(ch[u][c]==-1)
            {
                memset(ch[num],-1,sizeof(ch[num]));
                val[num]=0;
                ch[u][c]=num++;
            }
            u=ch[u][c];
        }
        val[u]=v;
    }
    void getFail()
    {
        queue <int> que;
        f[0]=0;
        for(int c=0;c<SIGMA_SIZE;c++)
        {
            int u=ch[0][c];
            if(u!=-1)
            {
                f[u]=0;que.push(u);
            }
            else
                ch[0][c]=0;//让其回到起始点
        }
        while(!que.empty())
        {
            int r=que.front();que.pop();
            if(val[f[r]])val[r]=val[f[r]];
            for(int c=0;c<SIGMA_SIZE;c++)
            {
                int u=ch[r][c];
                if(u==-1){ch[r][c]=ch[f[r]][c];continue;}
                que.push(u);
                f[u]=ch[f[r]][c];
            }
        }
    }
}AC;
int m,n;
char tem[15];

int main()
{
    while(~scanf("%d%d",&m,&n))
    {
        AC.init();
        for(int i=1;i<=m;i++){scanf("%s",tem);AC.insert(tem,i);}
        AC.getFail();
        matrix an(AC.num,AC.num);
        for(int i=0;i<AC.num;i++)
        {
            for(int j=0;j<4;j++)
            {
                if(!AC.val[i]&&!AC.val[AC.ch[i][j]])
                    an.e[i+1][AC.ch[i][j]+1]++;
            }
        }
        an=m_qpow(an,n);
        int re=0;
        for(int i=1;i<=AC.num;i++)
            re=(re+an.e[1][i])%MOD;
        printf("%d
",re);
    }
    return 0;
}