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 = 520;
const int maxlen = 2e6 + 5;

struct Matrix
{
    unsigned long long mat[111][111];
    int 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++)
                    ret.mat[i][j]+=mat[i][k]*b.mat[k][j] % 100000;
        return ret;
    }
    void print()
    {
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                printf("%d ", mat[i][j]);
            }
            printf("
");
        }
    }
};

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

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

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

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

void get_fail()
{
    queue<int>que;
    for(int i = 0; i < 4; i++){
        if(AC[0].son[i] != 0){
            AC[AC[0].son[i]].fail = 0;
            que.push(AC[0].son[i]);
        }
    }
    while(!que.empty()){
        int u = que.front();
        que.pop();
        for(int i = 0; i < 4; i++){
            if(AC[u].son[i] != 0){
                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 + 1);
    //int now = 0;
    for(int i = 0; i < tot + 1; i++){
        if(AC[i].danger)continue;
        for(int j = 0; j < 4; j++){
            if(AC[AC[i].son[j]].danger == false){
                ret.mat[i][AC[i].son[j]]++;
            }
        }
    }
    for(int i = 0; i < tot + 1; i++){
        ret.mat[i][tot] = 1;
    }
    return ret;
}

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

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