poj2778 DNA Sequence【AC自动机】【矩阵快速幂】

DNA Sequence

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 19991		Accepted: 7603

Description

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

Source

POJ Monthly--2006.03.26,dodo

题意：

给定m个致病基因序列。问长度为n的DNA序列中有多少个是没有这些序列的。

思路：

这道题用到AC自动机的状态转移的性质了。

当我建好了状态图之后，在某一个状态a时，我可以知道他可以到达的所有状态。Trie树上的一个节点就是一个状态。

初始矩阵mat[i][j]表示的是从状态i走一步到状态j有几种可能。使用矩阵快速幂，对这个矩阵做n次幂，就可以得到每个两个状态之间走n次总共有多少方案。

对于一个长为n的串，没有任何一个致病基因序列，那么所有致病基因转移过去的状态都不能算进去。

我们给每一个致病基因做一个危险标记，同时要注意所有fail可以到达的节点如果是danger的，他自己也要变成danger

因为这段致病基因作为后缀出现在这个串中了。

 #include <iostream>
 #include <set>
 #include <cmath>
 #include <stdio.h>
 #include <cstring>
 #include <algorithm>
 #include <vector>
 #include <queue>
 #include <map>
 //#include <bits/stdc++.h>
 using namespace std;
 typedef long long LL;
 #define inf 0x7f7f7f7f

 int m, n;
 const int maxn = ;
 const int maxlen = 2e6 + ;

 struct Matrix
 {
     unsigned long long mat[][];
     int n;
     Matrix(){}
     Matrix(int _n)
     {
         n=_n;
         for(int i=;i<n;i++)
             for(int j=;j<n;j++)
                 mat[i][j] = ;
     }
     Matrix operator *(const Matrix &b)const
     {
         Matrix ret = Matrix(n);
         for(int i=;i<n;i++)
             for(int j=;j<n;j++)
                 for(int k=;k<n;k++)
                     ret.mat[i][j]+=mat[i][k]*b.mat[k][j] % ;
         return ret;
     }
     void print()
     {
         for(int i = ; i < n; i++){
             for(int j = ; j < n; j++){
                 printf("%d ", mat[i][j]);
             }
             printf("\n");
         }
     }
 };

 unsigned long long pow_m(unsigned long long a, int n)
 {
     unsigned long long ret = ;
     unsigned long long tmp = a;
     while(n){
         if(n & )ret *= tmp;
         tmp *= tmp;
         n >>= ;
     }
     return ret;
 }

 Matrix pow_M(Matrix a, int n)
 {
     Matrix ret = Matrix(a.n);
     for(int i = ; i < a.n; i++){
         ret.mat[i][i] = ;
     }
     Matrix tmp = a;
     //cout<<a.n<<endl;
     while(n){
         if(n & )ret = ret * tmp;
         tmp = tmp * tmp;
         n >>= ;
         //ret.print();
         //cout<<endl;
     }
     return ret;
 }

 struct tree{
     int fail;
     int son[];
     bool danger;
 }AC[maxlen];
 int tot = , id[];
 char s[];

 void build(char s[])
 {
     int len = strlen(s);
     int now = ;
     for(int i = ; i < len; i++){
         int x = id[s[i]];
         if(AC[now].son[x] == ){
             AC[now].son[x] = ++tot;
         }
         now = AC[now].son[x];
     }
     AC[now].danger = true;
 }

 void get_fail()
 {
     queue<int>que;
     for(int i = ; i < ; i++){
         if(AC[].son[i] != ){
             AC[AC[].son[i]].fail = ;
             que.push(AC[].son[i]);
         }
     }
     while(!que.empty()){
         int u = que.front();
         que.pop();
         for(int i = ; i < ; i++){
             if(AC[u].son[i] != ){
                 AC[AC[u].son[i]].fail = AC[AC[u].fail].son[i];
                 que.push(AC[u].son[i]);
             }
             else{
                 AC[u].son[i] = AC[AC[u].fail].son[i];
             }
             int x = AC[AC[u].son[i]].fail;
             if(AC[x].danger){
                 AC[AC[u].son[i]].danger = true;
             }
         }
     }
 }

 /*int AC_query(char s[])
 {
     int len = strlen(s);
     int now = 0, cnt = 0;
     for(int i = 0; i < len; i++){
         int x = id[s[i]];
         now = AC[now].son[x];
         for(int t = now; t; t = AC[t].fail){
             if(!AC[t].vis && AC[t].ed != 0){
                 cnt++;
                 AC[t].vis = true;
             }
         }
     }
     return cnt;
 }*/

 Matrix getMatrix()
 {
     Matrix ret = Matrix(tot + );
     //int now = 0;
     for(int i = ; i < tot + ; i++){
         if(AC[i].danger)continue;
         for(int j = ; j < ; j++){
             if(AC[AC[i].son[j]].danger == false){
                 ret.mat[i][AC[i].son[j]]++;
             }
         }
     }
     for(int i = ; i < tot + ; i++){
         ret.mat[i][tot] = ;
     }
     return ret;
 }

 int main()
 {
     id['A'] = ;id['T'] = ;id['C'] = ;id['G'] = ;
     //cout<<1<<endl;
     while(~scanf("%d%d", &m, &n)){
         for(int i = ; i <= tot; i++){
             AC[i].fail = ;
             AC[i].danger = false;
             for(int j = ; j < ; j++){
                 AC[i].son[j] = ;
             }
         }
         tot = ;
         for(int i = ; i <= m; i++){
             scanf("%s", s);
             build(s);
         }
         AC[].fail = ;
         get_fail();
         Matrix mmm = Matrix(tot + );
         //int now = 0;
         for(int i = ; i < tot + ; i++){
             if(AC[i].danger)continue;
             for(int j = ; j < ; j++){
                 if(AC[AC[i].son[j]].danger == false){
                     mmm.mat[i][AC[i].son[j]]++;
                 }
             }
         }

         mmm = pow_M(mmm, n);
         unsigned long long res = ;
         for(int i = ; i < mmm.n; i++){
             res = (res + mmm.mat[][i]) % ;
         }

         printf("%lld\n", res);
     }
     //getchar();
     return ;
 }