DNA Sequence POJ

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

题意：

多组输入，n代表下面有n个模式串。m代表你要构造的DNA序列长度

题目让你求DNA序列为m，序列中不出现以上n个模式串的DNA序列有多少

题解：

我的上一代码用的我自己写的矩阵快速幂，那个版本每次都要初始化数组，太耗时了就TLE。找了个结构体版本的快速幂

这一道题就是问你你能找到多少个长度最长为m的正常DNA序列(什么叫正常？就是不含病毒的那种)
对于矩阵(这里以2*2为例)
|X(11) X(12)|
|X(21) X(22)|
我们设我们构造的矩阵为ans，其中ans[i][j]表示DNA序列中从i节点到j节点（下面都直接称为i、j）走一步的方法数(就是最后找出来的DNA序列中第i个位置和第j个
个位置,因为是一步，所以i和j在DNA序列中是相邻的。可以构成正常DNA的方法数)

什么叫i、j节点，我们在构造字典树的过程中会产生节点，那个节点是第几个产生的，那个就是它的序号

然后矩阵的二次方的ans[i][j]的意思就是从DNA序列中从i先到一个中转点再到j有多少种DNA序列满足
那么矩阵的n次方的ans[i][j]意思就是DNA序列中从i到n个中转点再到j有多少种DNA序列满足

那么我们只需要求出来ans[i][j]DNA序列中从i走一步的j这一段在DNA序列中方案数
然后这个矩阵求m次方就可以了

ans[i][j]DNA序列中从i走一步的j这一段在DNA序列中方案数的这个ans矩阵怎么求？

把每一个病毒串的终止位置给标记了，在字典树上通过失败指针跳转如果能到病毒串终止位置也要把这个点标记了，然后沿着字典树的next数组跑一边就完了(具体看代码)

然后第一行ans[0][1],ans[0][1]...ans[0][99]的所有数的和就可以了
ans[0][1]的意思就是从DNA序列0号位置(即，开头)经过m-1个中转点到1号节点 //0号位置是字典树根的位置，所以不算在DNA序列内
这个样子加起来就是答案

为什么可以这样做？

ans[i][j]最初的一步矩阵：

他就代表i这个点后面可以往j这个位置走一步有多少种不重复走法

ans[i][j]的m次方矩阵：

相当于字典树就是一个有向图，你就沿着它的方向跑下去。每跑m路程就会有一个对应DNA序列，又因为你已经把病毒串终止位置标记了，所以根本不可能跑到那个位置。所以你跑出来的DNA序列中也不会包含病毒序列

代码：

#include<stdio.h>  
#include<iostream>
#include<string.h>
#include<algorithm>
#include<queue>
using namespace std;
const int maxn=115;
const int N=4;
const int mod=100000;
typedef long long ll;
int n,m;
int w[120];
struct Matrix
{
    int mat[maxn][maxn],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 ret=Matrix(n);
        for(int i=0; i<n; i++)
            for(int j=0; j<n; j++)
                for(int k=0; k<n; k++)
                {
                    int tmp=(long long)mat[i][k]*b.mat[k][j]%mod;
                    ret.mat[i][j]=(ret.mat[i][j]+tmp)%mod;
                }
        return ret;
    }
};
struct Trie
{
    int next[maxn][N],fail[maxn],ends[maxn];
    int root,L;
    int New_node() //创建一个新节点
    {
        for(int i=0; i<N; ++i)
        {
            next[L][i]=-1;
        }
        ends[L++]=0;
        return L-1;
    }
    void init()  //创建根节点
    {
        L=0;
        root=New_node();
    }
    void inserts(char s[])  //往字典树里面插入新字符串
    {
        int len=strlen(s);
        int now=root;
        for(int i=0; i<len; ++i)
        {
            if(next[now][w[s[i]]]==-1)
                next[now][w[s[i]]]=New_node();
            now=next[now][w[s[i]]];
        }
        ends[now]=1;  //病毒串终点要标记
    }
    void build()
    {
        queue<int>r;
        fail[root]=root;
        for(int i=0; i<N; ++i)
        {
            if(next[root][i]==-1)
            {
                next[root][i]=root;
            }
            else
            {
                fail[next[root][i]]=root;
                r.push(next[root][i]);
            }
        }
        while(!r.empty())
        {
            int now=r.front();
            r.pop();
            if(ends[fail[now]])  //如果now节点的失败指针指向病毒串终点，那么也要把now这个点给标记了
            {
                ends[now]=1;
            }
            for(int i=0; i<N; ++i)
            {
                if(next[now][i]==-1)
                {
                    next[now][i]=next[fail[now]][i];  
                }
                else
                {
                    fail[next[now][i]]=next[fail[now]][i]; 
                    r.push(next[now][i]);
                }
            }
        }
    }
    Matrix Build_c()
    {
        Matrix res=Matrix(L);
        for(int i=0; i<L; ++i)
        {
            for(int j=0; j<N; ++j)
            {
                if(ends[next[i][j]]==0)  //创建走一步的ans矩阵
                {
                    res.mat[i][next[i][j]]++;
                }
            }
        }
        return res;
    }
};
char s[20];
Trie ac;
Matrix pow_M(Matrix a,int n)
{
    Matrix ret = Matrix(a.n);
    for(int i = 0; i < ret.n; i++)
        ret.mat[i][i]=1;
    Matrix tmp=a;
    while(n)
    {
        if(n&1)ret=ret*tmp;
        tmp=tmp*tmp;
        n>>=1;
    }
    return ret;
}
int main()
{
    w['A']=0;
    w['C']=1;
    w['G']=2;
    w['T']=3;
    while(~scanf("%d%d",&n,&m))
    {
        ac.init();
        while(n--)
        {
            scanf("%s",s);
            ac.inserts(s);
        }
        ac.build();
        Matrix ans=ac.Build_c();
        ans=pow_M(ans,m);
        int sum=0;
        for(int i=0; i<ac.L; ++i)
            sum+=ans.mat[0][i],sum%=mod;
        printf("%d
",sum);
    }
    return 0;
}