poj2778

题意,给出一些串,问m个字符组成的串不包含这些串的有多少种情况。

自动机加矩阵快速幂。

矩阵相乘就是第i行第j列的数就是前一个矩阵的第i行,与后一矩阵的第j列,要保证前一个矩阵的列数等于后一个矩阵的行数。

构造的时候,只要把那些通向结点或通向的点的fild指向结点的节点去掉,其他正常

#include<iostream>
#include<string.h>
#include<stdio.h>
#include<algorithm>
#include<queue>
#include<map>
using namespace std;
const int maxa = 105;
const int cha = 4;
#define LL long long
int n, m, k;
map<char, int> mp;
const int mod = 100000;
struct Matrix{
    int a[maxa][maxa];
    Matrix(){
        memset(a, 0, sizeof(a));
    }
    Matrix operator *(const Matrix &b)const
    {
        Matrix ret;
        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)a[i][k]*b.a[k][j]%mod;
                    ret.a[i][j]=(ret.a[i][j]+tmp)%mod;
                }
        return ret;
    }/*
    Matrix operator *(const Matrix &b) const{
        Matrix tmp;
        for(int i =0 ;i < n; i++){;
            for(int j = 0; j < n; j++){
                for(int k = 0;k  <n; k++){
                    LL lo = (LL) (tmp.a[i][j]) + (LL)(a[i][k]) *b.a[k][j];
                    lo %= mod;
                    tmp.a[i][j] = lo;
                }
            }
        }
        return tmp;
    }*/
};
struct Tire{
    int next[maxa][cha], fail[maxa], end[maxa];
    int root, L;
    int newnode(){
        for(int i = 0; i < cha; 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++){
            int x = mp[buf[i]];
            if(next[now][x] == -1)
                next[now][x] = newnode();
            now = next[now][x];
            //printf("%d ", now);
        }//puts("");
        end[now] ++;
    }
    void build(){
        queue<int>Q;
        fail[root] = root;
        for(int i = 0; i < cha; 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();
            if(end[fail[now]]){
                end[now] = 1;
            }
            Q.pop();
           // end[now] |= end[fail[now]];
            for(int i = 0; i < cha; 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]);
                   // printf("**%d %d\n",next[now][i],next[fail[now]][i]);
                }
            }
        }
    }
    Matrix make_Maxtrix(){
        Matrix tmp;
        for(int i = 0; i < L; i++){
            for(int k = 0; k < cha; k++){
                if(!end[next[i][k]]){
                    tmp.a[i][next[i][k]] ++;
                }
            }
        }
        return tmp;
    }
};
Matrix pow(Matrix a,int m)
{
    Matrix ret;// = Matrix(a.n);
    for(int i = 0; i < n; i++)
        ret.a[i][i]=1;
    Matrix tmp=a;
    while(m)
    {
        if(m&1)ret=ret*tmp;
        tmp=tmp*tmp;
        m>>=1;
    }
    return ret;
}
char buf[1000005];
Tire ac;
int main(){

mp[‘A‘] = 0;
mp[‘T‘] = 1;
mp[‘G‘] = 2;
mp[‘C‘] = 3;
    int N, M;
    while(scanf("%d%d", &N, &M)!=EOF){
        ac.init();
        while(N--){
            scanf("%s", buf);
            ac.insert(buf);
        }
        ac.build();
        n =  ac.L;
        Matrix a = ac.make_Maxtrix();
        Matrix b = pow(a, M);;
        int ans =0 ;
        for(int i = 0; i < n ;i++){
            ans += b.a[0][i];
            ans %= mod;
        }printf("%d\n", ans);
    }
}
/*
abcdefg
bcdefg
cdef
de
e
ssaabcdefg

*/

时间: 2024-10-15 13:26:49

poj2778的相关文章

【AC自动机】【矩阵乘法】poj2778 DNA Sequence

http://blog.csdn.net/morgan_xww/article/details/7834801 讲得很好~可以理解自动机的本质,就是一个用来状态转移的东西~对于确定的输入而言,可以从初始状态,按照转移边,转移到确定的终止状态. 而这种转移可以用矩乘加速. #include<cstdio> #include<cstring> #include<vector> #include<queue> #include<iostream> us

【POJ2778】DNA Sequence(AC自动机)

题意: 生物课上我们学到,DNA序列中只有A, C, T和G四种片段. 经科学发现,DNA序列中,包含某些片段会产生不好的基因,如片段"ATC"是不好片段,则"AGATCC", "CATCAA", "ATCATC"都是不好的DNA序列,这些不好片段我们可以称为病毒片段. 现在已知m个病毒片段, 问长度为n的DNA序列,有多少种可能不包含病毒片段.答案可能很大,取模 100000. [数据规模和约定] 0<=m<=1

【POJ2778】AC自动机,DP,矩阵乘法

题意:给出n个字串表示"缺陷基因",然后让求长度为m的基因(4^m个)中有多少个不带病. 题解:首先建立AC自动机,然后从每个节点开始选"ATGC"有四种往外转移的途径. 如:ACG,C这两个基因建一个ACauto,然后转移矩阵为下. 2 1 0 0 1 2 1 1 0 0 1 1 0 1 1 2 1 0 0 1 2 1 0 0 1 然后把危险状态删去(赋0),即基因结束节点的行和列. 然后矩阵变成 2 1 0 0 0 2 1 0 0 0 0 0 0 0 0 0 0

POJ2778&amp;HDU2243&amp;POJ1625(AC自动机+矩阵/DP)

POJ2778 题意:只有四种字符的字符串(A, C, T and G),有M中字符串不能出现,为长度为n的字符串可以有多少种. 题解:在字符串上有L中状态,所以就有L*A(字符个数)中状态转移.这里自动机的build的hdu2222略有不同. 那一题中通过询问时循环来求she的he,但是如果he不能出现,she就算不是禁止的字符串也不可出现,所以在build的时候就记录所有不能出现的状态. if (end[ fail[now] ]) end[now]++; 然后用一个矩阵F来记录可以相互到达的

POJ2778 DNA Sequence AC自动机上dp

网址:https://vjudge.net/problem/POJ-2778 题意: 给出字符集${A,C,G,T}$和一些字符串(长度不超过$10$,且数量不超过$10$个),求长度为$n(n \leq 2e9)$的字符串中不包括上面这些字符串的字符串的数量. 题解: 我们可以先考虑一种方式:设$dp(i,j)$是用了$i$个字符拼出符合题意的长度为$j$的字符串的数量,在本题中$dp(i,j)=\sum _{j' \subseteq j} dp(i-1,j')$,显然时间复杂度是指数级的,不

POJ2778 DNA Sequence Trie+矩阵乘法

题意:给定N个有A C G T组成的字符串,求长度为L的仅由A C G T组成的字符串中有多少个是不含给定的N个字符串的题解: 首先我们把所有的模式串(给定的DNA序列)建Trie,假定我们有一个匹配串,并且在匹配过程到S[i]这个字符时匹配到了Trie上的某个节点t,那么有两种可能: 匹配失败:t->child[S[i]]为空,跳转到t->fail,因此t->fail一定不能是某个模式串的结尾: 匹配成功:跳转到t->child[S[i+1]],因此t->child[S[i

poj2778 AC自动机

以下内容均为转载,,只有代码是自己写的=-= http://blog.csdn.net/morgan_xww/article/details/7834801   转载地址 博主写的很好 -------------------------------------------------------------------------------------------------------------------------------------------------------------

DNA Sequence(POJ2778 AC自动机dp+矩阵加速)

传送门 DNA Sequence Time Limit: 1000MS   Memory Limit: 65536K       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 sequenc

[POJ2778]DNA Sequence

看到n<=20亿顿时傻眼..AC自动机上用矩阵乘法优化DP...sxbk 建出AC自动机,把非法的节点去掉后求出trie图... 然后根据trie图中的转移关系建矩阵....最后跑个快速幂 竟然搞出来了...感人肺腑 脑子各种短路..先是矩乘打挂,然后是trie图求措TAT.调了一整节晚自修. 1 #include<cstdio> 2 #include<cstring> 3 #include<iostream> 4 #include<algorithm>