POJ 2778 DNA Sequence AC自动机 + 矩阵快速幂

最新推荐文章于 2020-02-02 20:44:43 发布
最新推荐文章于 2020-02-02 20:44:43 发布
阅读量774 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zmx354/article/details/38639089
版权

首先建立Trie和失败指针，然后你会发现对于每个节点 i 匹配AGCT时只有以下几种情况：

i 节点有关于当前字符的儿子节点 j 且安全，则i 到 j找到一条长度为 1的路。

i 节点有关于当前字符的儿子节点 j 且 不安全，则i 到 j没有路。

i 节点没有关于当前字符的儿子节点但是能通过失败指针找到一个安全的节点j，那么 i 到 j 找到一条长度为1的路。

关于节点安全的定义：

当前节点不是末节点且当前节点由失败指针指回跟节点的路径上不存在不安全节点，那么这个节点就是安全节点。

然后问题就转化成了从root到其它所有的安全节点有多少条长度为m的路径。

设A为此张Trie图的对应矩阵，那么A^m的第一行的sigma即为答案。


无意之间又自cha了一份自己在POJ AC的代码。。。

 数据：

3 10

AT

GATC

TGAC


正解：48233


这一份代码跑出50333竟然也过了。。

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <queue>
#include <cmath>
#include <stack>
#include <map>

#pragma comment(linker, "/STACK:1024000000");
#define EPS (1e-8)
#define LL long long
#define ULL unsigned long long
#define _LL __int64
#define INF 0x3f3f3f3f

using namespace std;

const int Mod = 100000;
const int MAXN = 110;
const int MAXS = 4;

struct Mat
{
    LL mat[MAXN][MAXN];
    int r,c;

    void Init(int val,int R,int C)
    {
        r = R,c = C;
        for(int i = 1;i <= r; ++i)
            for(int j = 1;j <= c; ++j)
                if(i != j)
                    mat[i][j] = 0;
                else
                    mat[i][j] = val;
    }
};

Mat MatrixMult(Mat a,Mat b)
{
    Mat p;
    p.Init(0,a.r,b.c);

    for(int i = 1;i <= a.r; ++i)
    {
        for(int j = 1;j <= b.c; ++j)
        {
            for(int k = 1;k <= b.r; ++k)
            {
                p.mat[i][j] += a.mat[i][k]*b.mat[k][j];
                p.mat[i][j] %= Mod;
            }
        }
    }

    return p;
}

Mat QuickMult(_LL k,Mat coe)
{
    Mat p;

    p.Init(1,coe.r,coe.c);

    while(k >= 1)
    {
        if(k&1)
            p = MatrixMult(p,coe);
        coe = MatrixMult(coe,coe);
        k >>= 1;
    }

    return p;
}

struct N
{
    int next[MAXS],flag,fail;
}st[110];

int Top;

int creat()
{
    for(int i = 0;i < MAXS; ++i)
        st[Top].next[i] = -1;
    st[Top].fail = -1,st[Top].flag = 0;
    return Top++;
}

char s[12];

int sel(char c)
{
    if(c == 'A')
        return 0;
    if(c == 'G')
        return 1;
    if(c == 'C')
        return 2;
    return 3;
}

void Get_Trie(int root,char *s)
{
    int site = 1;
    while(s[site] != '\0')
    {
       if(st[root].next[sel(s[site])] == -1)
            st[root].next[sel(s[site])] = creat();
        root = st[root].next[sel(s[site])];
        ++site;
    }

    st[root].flag++;
}

queue<int> q;

int Get_Fail(int site,int tar)
{
    while(site != -1 && st[site].next[tar] == -1)
        site = st[site].fail;
    if(site == -1)
        return 0;
    return st[site].next[tar];
}

void Get_Fail(int root)
{
    st[root].fail = -1;

    q.push(root);

    int f;

    while(q.empty() == false)
    {
        f = q.front();
        q.pop();
        for(int i = 0;i < MAXS; ++i)
        {
            if(st[f].next[i] != -1)
            {
                st[st[f].next[i]].fail = Get_Fail(st[f].fail,i);
                q.push(st[f].next[i]);
            }
        }
    }
}

bool mark[110];

bool Check(int site)
{
    if(site == -1)
        return true;
    if(st[site].flag != 0 || Check(st[site].fail) == false)
        return false;
    return true;
}

int Check(int site,int tar)
{
    if(site == -1)
        return 0;
    if(st[site].next[tar] != -1)
    {
        if(st[st[site].next[tar]].flag != 0)
            return -1;
        return st[site].next[tar];
    }
    return Check(st[site].fail,tar);
}

void Cal_Mat(int root,Mat &p)
{
    memset(mark,false,sizeof(mark));

    mark[root] = true;

    q.push(root);

    int f;

    while(q.empty() == false)
    {
        f = q.front();
        q.pop();
        for(int i = 0;i < MAXS; ++i)
        {
            if(st[f].next[i] != -1 && Check(st[f].next[i]))
            {
                p.mat[f+1][st[f].next[i]+1]++;
                q.push(st[f].next[i]);
            }
            else if(st[f].next[i] == -1)
            {
                int tmp =  Check(f,i);
                if(tmp != -1)
                    p.mat[f+1][tmp+1]++;
            }
        }
    }
}

int main()
{
    int root,i,n,m;

    while(scanf("%d %d",&n,&m) != EOF)
    {
        Top = 0;
        root = creat();
        for(i = 1;i <= n; ++i)
        {
            scanf("%s",s+1);
            Get_Trie(root,s);
        }

        Get_Fail(root);

        Mat p;
        p.Init(0,Top,Top);
        Cal_Mat(root,p);

        p = QuickMult(m,p);

        LL ans = 0;

        for(i = 1;i <= Top; ++i)
            ans += p.mat[1][i],ans %= Mod;
        printf("%lld\n",ans);
    }

    return 0;
}


附上正解代码。。。

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <queue>
#include <cmath>
#include <stack>
#include <map>

#pragma comment(linker, "/STACK:1024000000");
#define EPS (1e-8)
#define LL long long
#define ULL unsigned long long
#define _LL __int64
#define INF 0x3f3f3f3f

using namespace std;

const int Mod = 100000;
const int MAXN = 110;
const int MAXS = 4;

struct Mat
{
    LL mat[MAXN][MAXN];
    int r,c;

    void Init(int val,int R,int C)
    {
        r = R,c = C;
        for(int i = 1;i <= r; ++i)
            for(int j = 1;j <= c; ++j)
                if(i != j)
                    mat[i][j] = 0;
                else
                    mat[i][j] = val;
    }
};

Mat MatrixMult(Mat a,Mat b)
{
    Mat p;
    p.Init(0,a.r,b.c);

    for(int i = 1;i <= a.r; ++i)
    {
        for(int j = 1;j <= b.c; ++j)
        {
            for(int k = 1;k <= b.r; ++k)
            {
                p.mat[i][j] += a.mat[i][k]*b.mat[k][j];
                p.mat[i][j] %= Mod;
            }
        }
    }

    return p;
}

Mat QuickMult(_LL k,Mat coe)
{
    Mat p;

    p.Init(1,coe.r,coe.c);

    while(k >= 1)
    {
        if(k&1)
            p = MatrixMult(p,coe);
        coe = MatrixMult(coe,coe);
        k >>= 1;
    }

    return p;
}

struct N
{
    int next[MAXS],flag,fail;
}st[110];

int Top;

int creat()
{
    //memset(st[Top].next,-1,sizeof(st[Top].next));
    for(int i = 0;i < MAXS; ++i)
        st[Top].next[i] = -1;
    st[Top].fail = -1,st[Top].flag = 0;
    return Top++;
}

char s[12];

int sel(char c)
{
    if(c == 'A')
        return 0;
    if(c == 'G')
        return 1;
    if(c == 'C')
        return 2;
    return 3;
}

void Get_Trie(int root,char *s)
{
    int site = 1;
    while(s[site] != '\0')
    {
        if(st[root].next[sel(s[site])] == -1)
            st[root].next[sel(s[site])] = creat();
        root = st[root].next[sel(s[site])];
        ++site;
    }

    st[root].flag++;
}

queue<int> q;

int Get_Fail(int site,int tar)
{
    while(site != -1 && st[site].next[tar] == -1)
        site = st[site].fail;
    if(site == -1)
        return 0;
    return st[site].next[tar];
}

void Get_Fail(int root)
{
    st[root].fail = -1;

    q.push(root);

    int f;

    while(q.empty() == false)
    {
        f = q.front();
        q.pop();
        for(int i = 0;i < MAXS; ++i)
        {
            if(st[f].next[i] != -1)
            {
                st[st[f].next[i]].fail = Get_Fail(st[f].fail,i);
                q.push(st[f].next[i]);
            }
        }
    }
}

bool mark[110];

bool Check(int site)
{
    if(site == -1)
        return true;
    if(st[site].flag != 0 || Check(st[site].fail) == false)
        return false;
    return true;
}

int Check(int site,int tar)
{
    if(site == -1)
        return 0;
    if(st[site].next[tar] != -1)
    {
        if(st[st[site].next[tar]].flag != 0)
            return -1;
        return st[site].next[tar];
    }
    return Check(st[site].fail,tar);
}

void Cal_Mat(int root,Mat &p)
{
    memset(mark,false,sizeof(mark));

    mark[root] = true;

    q.push(root);

    int f;

    while(q.empty() == false)
    {
        f = q.front();
        q.pop();
        for(int i = 0;i < MAXS; ++i)
        {
            if(st[f].next[i] != -1 && Check(st[f].next[i]))
            {
                p.mat[f+1][st[f].next[i]+1]++;
                q.push(st[f].next[i]);
            }
            else if(st[f].next[i] == -1)
            {
                int tmp =  Check(f,i);
                if(tmp != -1 && Check(tmp))
                    p.mat[f+1][tmp+1]++;
            }
        }
    }
}

int main()
{
    int root,i,n,m;

    while(scanf("%d %d",&n,&m) != EOF)
    {
        Top = 0;
        root = creat();
        for(i = 1;i <= n; ++i)
        {
            scanf("%s",s+1);
            Get_Trie(root,s);
        }

        Get_Fail(root);

        Mat p;
        p.Init(0,Top,Top);

        Cal_Mat(root,p);

        p = QuickMult(m,p);

        LL ans = 0;

        for(i = 1;i <= Top; ++i)
            ans += p.mat[1][i],ans %= Mod;
        printf("%lld\n",ans);
    }

    return 0;
}


自在_飞花
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
POJ - 2778 DNA Sequence(AC自动机+矩阵快速幂)
Falcon的博客
02-05 244
题目链接：点击查看 题目大意：给出 n 个长度不大于 10 的字符串表示病毒串，再给出一个长度 len ，问长度为 len 的字符串中，有多少个字符串不含有病毒串作为子串 题目分析：因为病毒串的长度和数量均不大于 10 ，所以我们对病毒串构造AC自动机后会有最多 100 个结点代表 100 个状态，注意对病毒串的标记，在构造AC自动机时记得把标记下传，因为某个节点如果是病毒串的话，那么含有该前...
poj--2778DNA Sequence+AC自动机+矩阵快速幂
荒野孤鹰
08-24 1285
题目链接：点击进入 如果我们先将所有的病毒字符串构建成一棵trie，然后构建一个n长的字符串的过程可以看成是从这颗trie树根节点出发走n步的一个过程，为了不含任何的病毒，则在走的过程中不能经过任何的病毒节点。考虑只走一步的过程，则我们可以得到一个矩阵m[i][j],表示从节点i到节点j有多少种方式。那么这个矩阵的n次幂就是表示走n步的情况，然后也就可以得到答案了。 问题在于如何获得这个走一步方
[POJ]2778 DNA Sequence AC自动机 + 矩阵快速幂
Le Petit Prince
02-04 442
DNA Sequence Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 18408   Accepted: 7094 Description It's well known that DNA Sequence is a sequence only contai
DNA Sequence 【POJ - 2778】【AC自动机+矩阵快速幂】
既然弱小，就只顾变强就是了
01-20 223
题目链接 哇哇哇！！！过啦，美滋滋，捋了半天题意，不解为何最后答案为0，然后就一直一直的debug，后来发现竟然是在写字典树的时候写彪了……呜呜呜，好气啊QAQ…… 题目的思路倒也却是很有奥妙，也特别的有意思（尤其是想到之后），我们看到有长达"2e9"的步数得去走，就想到了用矩阵快速幂，[i][j]指的是从i到j所需要的路径可能的数量。然后，我们找到N步之后的所有从[0]状态到达的全体...
POJ2778 DNA Sequence AC自动机+矩阵快速幂
jijijix的博客
02-17 741
题目描述：给出m(m        这道题目深层次地利用了AC自动机，但是并没有用到AC自动机中的find(query)函数，而是用到了BFS序建立失败指针走向，以及为字典树中的空节点加上侧向边的BFS函数（或者有的叫getFail函数），所以，在继续读之前，确保已经非常清楚AC自动机为字典树加上侧向边是怎么回事。       看下面的例子，模式串的集合为{ATC ， T}，那么建完
poj2778 DNA Sequence（AC自动机+矩阵快速幂）
Crazy_Bear
09-02 627
题目链接：点击打开链接 题意描述：给m字符串，这m个字符串是带有病毒的DNA。然后问一个长度为n的字符串不带有任何病毒有多少中可能？所有字符串之后ACGT这几个字符串组成 解题思路：AC自动机+矩阵快速幂 前置内容：邻接矩阵幂的含义：点击打开链接 分析：首先根据题意先建一个AC自动机，其实AC自动机本身就是一张图，AC自动机中的每个结点就相当于图中的顶点，每个转移A、C、G、T就相
POJ 2778 DNA Sequence(AC自动机+矩阵快速幂)
smilestruggler_Fly To Higher
02-02 236
题目链接：http://poj.org/problem?id=2778   题目大意：   给出m个字符串，求长度为n且不包含给出字符串的字符串个数   题目思路：   推荐博客：传送门   这道题一共分为两步，第一步是得到字典树上每个节点走一步到达各个节点的合法方案数(起点和终点不能为非法节点，非法节点的定义下面介绍)，这个方案数通过矩阵存储，第i行第j列表示从i节点表示的状...
poj2778 DNA Sequence(AC自动机+矩阵快速幂)
Code92007的博客
02-15 233
题目 给你一个m，一个n， m个要被禁止的模式串， 问长度恰为n的串里， 不包含任意一个模式串的方案数是多少 方案数模10W 思路来源 https://blog.csdn.net/morgan_xww/article/details/7834801（思路，强烈推荐，博主好文） https://blog.csdn.net/u013446688/article/details/4737...
POJ2778 DNA Sequence(AC自动机+矩阵快速幂)
riba2534的博客
11-05 527
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 contai
POJ-2778 ac自动机+矩阵快速幂
AC_Machine的博客
10-02 510
DNA Sequence Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 15422   Accepted: 5954 Description It's well known that DNA Sequence is a sequence only contains
北大POJ初级-所有题目AC代码+解题报告
07-31
【标题】"北大POJ初级-所有题目AC代码+解题报告" 涉及的知识点主要集中在编程、算法和在线判题系统方面。北京大学（Peking University, 简称PKU）的POJ（Peking University Online Judge）是一个为计算机科学爱好者...
深入探讨POJ 2312 Battle City 优先队列+BFS
09-05
【深入探讨POJ 2312 Battle City 优先队列+BFS】 本文将详细剖析在解决POJ 2312 Battle City问题时，如何结合优先队列和BFS（宽度优先搜索）来实现高效的算法。问题背景是基于大家熟悉的坦克大战游戏，坦克需要从...
北大POJ初级题-数据结构：解题报告+AC代码
07-31
本资源包含的是北大POJ初级题目的解题报告以及通过验证（Accepted，简称AC）的代码，主要针对数据结构这一核心计算机科学领域。 数据结构是计算机科学中的基石，它研究如何在内存中组织和管理数据，以便高效地执行...
POJ.rar_pku ac_pku.1050
09-24
标题中的"POJ.rar_pku ac_pku.1050"暗示了这是一个与北京大学(Peking University, 简称PKU)编程竞赛相关的压缩文件，其中包含了作者通过验证(Passed All Cases, 简称AC)的代码，具体是针对PKU题目编号1050的问题。...
浅谈LCA的几种算法
自在飞花
01-10 9247
LCA,Lowest Common Ancestor,最近的公共祖先。在一棵树中对于两个节点u , v找出节点T，使得T同时为u，v的祖先。显然这样的T点肯定存在且有可能有多个，其中深度最大的那个点肯定为即为u，v两点的LCA。关于LCA的解法有很多种，暴力枚举，事先需要知道所有询问的离线的tarjan算法和基于RMQ的在线算法，下面说一下自己对这种几种算法的理解。   ⒈最容易想到的暴力搜索
浅谈二维中的树状数组与线段树
自在飞花
06-17 1413
一般来说，树状数组可以实现的东西线段树均可胜任，实际应用中也是如此。但是在二维中，线段树的操作变得太过复杂，更新子矩阵时第一维的lazy标记更是麻烦到不行。 但是树状数组在某些询问中又无法胜任，如最值等不符合区间减法的询问。此时就需要根据线段树与树状数组的优缺点来选择了。 做一下基本操作的对比，如下图。 因为线段树为自上向下更新，从而可以使用lazy标记使得矩阵的更新变的高校起来，几个不
二维树状数组的区间加减及查询 tyvj 1716 上帝造题的七分钟
自在飞花
06-17 1361
具体解释见小结。 #include #include #include #include #include #include #include #include #include #pragma comment(linker, "/STACK:1024000000"); #define EPS (1e-8) #define LL long long #define ULL u
CodeForces 385C Bear and Prime Numbers 线段树+素数筛
自在飞花
01-25 1303
题意：首先给你N个数。然后有M次询问，每次询问给出一段区间，首先找出这段区间内的所有素数，然后计算对于这段区间内第 i 的素数Pi，这N个数中有多少个数能被Pi整除，设有Si个数能被Pi整除，然后输出Si的和。 思路：因为这个N个数的范围为 [ 2 , 1000W]memset(mark,0,sizeof(mark)); for(i = 2;i <= 10000000; ++i)
SDUT 1232 / POJ 1785 Binary Search Heap Construction
自在飞花
02-22 1164
最近总是不在状态，满脑子都是有的没的，感觉乱糟糟的。计划也越来越难了，做起来各种力不从心。好像整个人已经走在失控的边缘了。笑里春秋多少泪。唉。 好了，下面扯题。 给出N对字符串和数字，然后建树。要求字符串符合排序二叉树，数字符合堆性质。然后按照中序遍历顺序输出。 好了，思路已经很明确了，明显的Treap。以前做过一个询问区间第K大的数的题，貌似这种数据结构可以胜任，可是宝哥给我推荐了划分树.
用java解决POJ3233—矩阵幂序列问题
最新发布
11-19
以下是Java解决POJ3233—矩阵幂序列问题的代码和解释： ```java import java.util.Scanner; public class Main { static int n, k, m; static int[][] A, E; public static void main(String[] args) { Scanner sc = new Scanner(System.in); n = sc.nextInt(); k = sc.nextInt(); m = sc.nextInt(); A = new int[n][n]; E = new int[n][n]; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { A[i][j] = sc.nextInt() % m; E[i][j] = (i == j) ? 1 : 0; } } int[][] res = matrixPow(A, k); int[][] ans = matrixAdd(res, E); printMatrix(ans); } // 矩阵乘法 public static int[][] matrixMul(int[][] a, int[][] b) { int[][] c = new int[n][n]; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { for (int k = 0; k < n; k++) { c[i][j] = (c[i][j] + a[i][k] * b[k][j]) % m; } } } return c; } // 矩阵快速幂 public static int[][] matrixPow(int[][] a, int b) { int[][] res = E; while (b > 0) { if ((b & 1) == 1) { res = matrixMul(res, a); } a = matrixMul(a, a); b >>= 1; } return res; } // 矩阵加法 public static int[][] matrixAdd(int[][] a, int[][] b) { int[][] c = new int[n][n]; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { c[i][j] = (a[i][j] + b[i][j]) % m; } } return c; } // 输出矩阵 public static void printMatrix(int[][] a) { for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { System.out.print(a[i][j] + " "); } System.out.println(); } } } ``` 解释： 1. 首先读入输入的n、k、m和矩阵A，同时初始化单位矩阵E。 2. 然后调用matrixPow函数求出A的k次幂矩阵res。 3. 最后将res和E相加得到结果ans，并输出。 4. matrixMul函数实现矩阵乘法，matrixPow函数实现矩阵快速幂，matrixAdd函数实现矩阵加法，printMatrix函数实现输出矩阵。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值