AC自动机（hdu 2896 hdu 3065）

最新推荐文章于 2018-04-07 19:46:25 发布
最新推荐文章于 2018-04-07 19:46:25 发布
阅读量309 收藏
点赞数
分类专栏： ××××××算法学习×××××× ------数据结构------ 数据结构------AC自动机 文章标签： AC自动机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/M_GSir/article/details/52411343
版权

题目：hdu 2896

题意：中文题目，可自己理解，简单说就是给定一些子字符串，再给出一些母字符串，找出母字符串中包含哪些子字符串

题解：AC自动机模板题

代码：

动态申请：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<queue>
#define MAX 59999

using namespace std;
struct Node
{
    int number;
    Node *next[128];
    Node *fail;
    Node()
    {
        number=0;
        fail=NULL;
        for(int i=0;i<128;i++)
            next[i]=NULL;
    }
};
queue<Node*> q;
Node *root;
bool vis[600];
int no;
char son[256];
char father[100500];
void insertTree(char *s)
{
    int len=strlen(s);
    int index;
    Node *temp=root;
    for(int i=0;i<len;i++)
    {
        index=s[i]-' ';
        if(temp->next[index]==NULL)
        {
            temp->next[index]=new Node();
        }
        temp=temp->next[index];
    }
    temp->number=no++;
}
void buildacfail()
{
    q.push(root);
    Node *temp;
    Node *p;
    while(!q.empty())
    {
        temp=q.front();
        q.pop();
        for(int i=0;i<128;i++)
        {
            if(temp->next[i]!=NULL)
            {
                if(temp==root)
                {
                    temp->next[i]->fail=root;
                }
                else
                {
                    p=temp->fail;
                    while(p!=NULL)
                    {
                        if(p->next[i]!=NULL)
                        {
                            temp->next[i]->fail=p->next[i];break;
                        }
                        p=p->fail;
                    }
                    if(p==NULL)
                    {
                        temp->next[i]->fail=root;
                    }
                }
                q.push(temp->next[i]);
            }
        }
    }
}
int query(char *s)
{
    int len=strlen(s);
    Node *temp=root;
    Node *p;
    int index;
    int sum=0;
    for(int i=0;i<len;i++)
    {
        index=s[i]-' ';
        while(temp->next[index]==NULL && temp!=root)
        {
            temp=temp->fail;
        }
        temp=temp->next[index];
        if(temp==NULL)
        {
            temp=root;
        }
        p=temp;
        while(temp!=root && !vis[temp->number])
        {
            if(temp->number)
            {
                sum++;vis[temp->number]=1;
            }
            temp=temp->fail;
        }
        temp=p;
    }
    return sum;
}
int main()
{
    int n,m,sum;
    while(~scanf("%d", &n))
    {
        root =new Node();
        no=1;
        getchar();
        for(int i = 0; i < n; ++i)
        {
            gets(son);
            insertTree(son);
        }
        buildacfail();
        scanf("%d",&m);
        getchar();
        memset(vis,0,sizeof(vis));
        sum=0;
        for(int i=0;i<m;i++)
        {
            scanf("%s", father);
            int count1=query(father);
            if(count1)
            {
                sum++;
                printf("web %d:",i+1);
                for(int j=1;j<=n;j++)
                {
                    if(vis[j]){printf(" %d",j);vis[j]=0;count1--;}
                    if(!count1) break;
                }
                printf("\n");
            }
        }
        printf("total: %d\n",sum);
    }
    return 0;
}

静态存储：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<queue>

using namespace std;
struct Node
{
    int number;
    Node *next[128];
    Node *fail;
};
queue<Node*> q;
Node *root;
Node node[1000050];
int num;
int no;
bool vis[505];
char son[300];
char father[10050];
void declear(Node *p)
{
    p->number=0;
    p->fail=NULL;
    for(int i=0;i<128;i++)
    {
        p->next[i]=NULL;
    }
}
void insertTree(char *s)
{
    int len=strlen(s);
    int index;
    Node *temp=root;
    for(int i=0;i<len;i++)
    {
        index=s[i]-' ';
        if(temp->next[index]==NULL)
        {
            temp->next[index]=&node[num];
            declear(node+num);
            num++;
        }
        temp=temp->next[index];
    }
    temp->number=no++;
}
void buildacfail()
{
    q.push(root);
    Node *temp;
    Node *p;
    while(!q.empty())
    {
        temp=q.front();
        q.pop();
        for(int i=0;i<128;i++)
        {
            if(temp->next[i]!=NULL)
            {
                if(temp==root)
                {
                    temp->next[i]->fail=root;
                }
                else
                {
                    p=temp->fail;
                    while(p!=NULL)
                    {
                        if(p->next[i]!=NULL)
                        {
                            temp->next[i]->fail=p->next[i];break;
                        }
                        p=p->fail;
                    }
                    if(p==NULL)
                    {
                        temp->next[i]->fail=root;
                    }
                }
                q.push(temp->next[i]);
            }
        }
    }
}
int query(char *s)
{
    int len=strlen(s);
    Node *temp=root;
    Node *p;
    int index;
    int sum=0;
    for(int i=0;i<len;i++)
    {
        index=s[i]-' ';
        while(temp->next[index]==NULL && temp!=root)
        {
            temp=temp->fail;
        }
        temp=temp->next[index];
        if(temp==NULL)
        {
            temp=root;
        }
        p=temp;
        while(temp!=root && !vis[temp->number]) //考虑重复情况，不用记录次数，只要记录之前有没出现过即可，后面的就不用考虑了
        {
            if(temp->number!=0)
            {
                sum++;
                vis[temp->number]=1;
            }
            temp=temp->fail;
        }
        temp=p;
    }
    return sum;
}
int main()
{
    int n,m,sum;
    while(~scanf("%d", &n))
    {
        root = node;
        num=1;
        no=1;
        declear(node);
        getchar();
        for(int i = 0; i < n; ++i)
        {
            gets(son);
            insertTree(son);
        }
        buildacfail();
        scanf("%d",&m);
        getchar();
        memset(vis,0,sizeof(vis));
        sum=0;
        for(int i=0;i<m;i++)
        {
            scanf("%s", father);
            int count1=query(father);
            if(count1)
            {
                sum++;
                printf("web %d:",i+1);
                for(int j=1;j<=n;j++)
                {
                    if(vis[j]){printf(" %d",j);vis[j]=0;count1--;}
                    if(!count1) break;
                }
                printf("\n");
            }
        }
        printf("total: %d\n",sum);
    }
    return 0;
}


题目：hdu 3065

题意：中文题目，简单说就是给定一些大写字母组成的子串，再给出母串，求其母串中子串各出现了多少次

题解：AC模板题，主要解释看注释

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<queue>

using namespace std;
struct Node
{
    int number;
    Node *next[26];
    Node *fail;
};
queue<Node*> q;
Node *root;
Node node[5000050];
int num;
int no;
int vis[1505];
char son[1005][60];
char father[2000500];
void declear(Node *p)
{
    p->number=0;
    p->fail=NULL;
    for(int i=0;i<26;i++)
    {
        p->next[i]=NULL;
    }
}
void insertTree(char *s)
{
    int len=strlen(s);
    int index;
    Node *temp=root;
    for(int i=0;i<len;i++)
    {
        index=s[i]-'A';
        if(temp->next[index]==NULL) //增加节点
        {
            temp->next[index]=&node[num];
            declear(node+num);
            num++;
        }
        temp=temp->next[index];
    }
    temp->number=no++;
}
void buildacfail()
{
    q.push(root);
    Node *temp;
    Node *p;
    while(!q.empty())
    {
        temp=q.front();
        q.pop();
        for(int i=0;i<26;i++)
        {
            if(temp->next[i]!=NULL)
            {
                if(temp==root)
                {
                    temp->next[i]->fail=root;
                }
                else
                {
                    p=temp->fail;
                    while(p!=NULL)
                    {
                        if(p->next[i]!=NULL)
                        {
                            temp->next[i]->fail=p->next[i];break;
                        }
                        p=p->fail;
                    }
                    if(p==NULL)
                    {
                        temp->next[i]->fail=root;
                    }
                }
                q.push(temp->next[i]);
            }
        }
    }
}
void query(char *s)
{
    int len=strlen(s);
    Node *temp=root;
    Node *p;
    int index;
    for(int i=0;i<len;i++)
    {
        index=s[i]-'A';
        if(index>=26 ||index<0 ) {temp=root;continue;}
        while(temp->next[index]==NULL && temp!=root)
        {
            temp=temp->fail;
        }
        temp=temp->next[index];
        if(temp==NULL)
        {
            temp=root;
        }
        p=temp;
        while(temp!=root) //全部进行遍历，而不是，这道题改的就是这里，不是重新开始，而是顺着现在的遍历，一定不会重复
        {
            if(temp->number!=0)
            {
                vis[temp->number]++;
            }
            temp=temp->fail;
        }
        temp=p;
    }
}
int main()
{
    int n,m,sum;
    while(~scanf("%d", &n))
    {
        memset(vis,0,sizeof(vis));
        root = node;
        num=1;
        no=1;
        declear(node);
        getchar();
        for(int i = 0; i < n; ++i)
        {
            gets(son[i]);
            insertTree(son[i]);
        }
        buildacfail();
        scanf("%s", father);
        query(father);
        for(int i=1;i<=n;i++)
        {
            if(vis[i]) printf("%s: %d\n",son[i-1],vis[i]);
        }
    }
    return 0;
}


M_GSir
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hdu2896(AC自动机）
qq_41780519的博客
05-07 158
这个题有一个非常坑的点 就是网址不一定是小写字母！！ 还有就是这个题卡空间卡到令人窒息 子节点数组开到130即可 节点最大个数210*500即可 但是要注意不是小写字母的话下文代码处原本的s[j]-'a'要变为s[j]-'\0' （不如叫RE-ME-WA自动机好了） #include<iostream> #include<cstdio> #include&lt...
AC自动机 HDU 2896
weixin_30770783的博客
01-05 58
n个字串 m个母串 字串在母串中出现几次 #include<stdio.h> #include<algorithm> #include<string.h> #include<queue> #include<vector> using namespace std; #define MAXN 130 //...
AC自动机 hdu2896 hdu3065 病毒侵袭
我的指针和我一样找不到对象
08-13 410
hdu2896 题意：在文本串中找出所包含的模式串，并计数有多少文本串，具体可看            hdu2896 http://acm.hdu.edu.cn/showproblem.php?pid=2896 知道AC自动机就很好做了 推荐的学习链接: http://acm.uestc.edu.cn/bbs/read.php?tid=4294 http://blog.csdn.ne
HDU 2896（AC自动机）
qq_40828805的博客
04-07 152
原题链接题意：有N个病毒特征码（编号从1——N），M个网站源码（编号从1——M）。问每一个网站源码中含有哪些病毒特征码，输出特征码编号（没有就不输出）。最后输出总共有多少个网站有病毒。思路：AC自动机裸题，主要是要理解AC自动机的思想，他是一种解决多模式匹配的算法，fail指针的作用类似于KMP中的nextval数组的作用，是当前位置失配后，下一个字符比较的位置。   大佬讲解（结合图片中的例子看...
HDU2896【AC自动机-模板】
ONE MORE TRY
02-11 874
思路： 因为不同病毒特征码不会相同。 AC自动机，然后对于每一个输出即可。 注意：以上字符串中字符都是ASCII码可见字符（不包括回车）;G++ MLE。 //#include #include #include #include #include #include using namespace std; const int N=1e5+10;    /
AC 自动机 HDU 2896
Rain Stopped的博客
05-11 382
自动机水题，注意输出的是web的编号不一定连续以及别忘了输出冒号 #include using namespace std; int ans[505],n,m,sum; char buf[10010],str[505][205]; struct Trie { int next[505*205][128],fail[505*205],end[505*205]; int root,
ac自动机 hdu 2896. 病毒侵袭
bllsll
06-07 239
差点忘了写。一开始RE，因为和之前一样id=str[i]-‘a’. 这里不用减。。。 然后开始Mle，把数组模拟队列改为了队列，然后c++提交#include <iostream> #include <cstring> #include <algorithm> #include <cstdio> #include <cmath> #include <queue> using namespace
HDU 2896 (AC自动机)
aekijekzn484879763的博客
07-16 75
HDU 2896 病毒侵袭 Problem : 给n个模式串，m个目标串，询问每个目标串含有哪些模式串。 Solution : 将模式串建立AC自动机，对于每个目标串，开一个数组表示每个模式串是否匹配，在AC自动机上跑一遍即可。 #include <iostream> #include <string> #include <queue> using ...
AC自动机 HDU3065
Rain Stopped的博客
05-11 492
自动机水题  注意多组输入！！！！ #include using namespace std; int ans[1001],n; char buf[2000010],str[1001][55]; struct Trie { int next[50001][128],fail[50010],end[50001]; int root,L; int newnode()
AC自动机_AC自动机模板_
09-30
供信息学奥林匹克竞赛选手使用 AC自动机模板
ac自动机.pptx
07-14
要学AC自动机需要自备两个前置技能:KMP和trie树(其实个人感觉不会kmp也行,失配指针的概念并不难) 其中,KMP是用于一对一的字符串匹配,而trie虽然能用于多模式匹配,但是每次匹配失败都需要进行回溯,如果模式串很长的话...
中文高性能AC自动机代码
11-05
C语言实现，效率极高，实现了中文的关键字匹配，输出的格式为偏移量加上关键字（中文编码为GB2312）
经典AC自动机.cpp
08-19
ac自动机,就是在tire树的基础上,增加一个fail指针,如果当前点匹配失败,则将指针转移到fail指针指向的地方,这样就不用回溯,而可以路匹配下去了
AC自动机
03-06
基于字典树的ac自动机，自己前期的实现，具有源码参考，用于查找可屏蔽应用
KM算法（完备匹配下的最大权匹配）
M_GSir的博客
10-24 2328
KM算法求的是完备匹配下的最大权匹配： 在一个二分图内，左顶点为X，右顶点为Y，现对于每组左右连接XiYj有权wij，求一种匹配使得所有wij的和最大。 题目：http://acm.hdu.edu.cn/showproblem.php?pid=2255 题意：分房子，对于n个人对n所房子有自己的最大承受价格，要求每个人分到一所房子，并且要求收入最大 输入说明：输入n，代表n个人和n所房子
2-sat(强连通分量求法一 判断是否存在解法)
M_GSir的博客
10-23 1599
好博客链接:http://www.cnblogs.com/ambition/archive/2011/07/30/2-sat.html(内有ppt讲解、题集、论文) 建图如上篇一样，主要不同是上篇利用暴力来求，但上篇可以保证按字典序最小进行输出，此处利用了比较好的算法，产生了o（m）的复杂度，应用于所有题，主要思路是利用了图的对称的原理，根据建图后可知，若存在强连通图，则其中选择了一个，其他点也
超大01背包（hdu 5887）
M_GSir的博客
09-17 1381
题目：http://acm.hdu.edu.cn/showproblem.php?pid=5887 题意：01背包，就是收集草药，每个收集和整理的过程需要时间，整理收集完一个草药会获得一定的分数，要求在限定时间内整理和收集的草药得到的分数最高，就是数据范围有点大，到10的9次方 题解：范围太大，不能用一般的数组存下，10的9次方，内存会爆，可以采用减少内存的办法，即是每次记录可以达到的重量
网络流最大流算法（ISAP算法及DINIC算法）
M_GSir的博客
08-24 1163
这些算法网络中解释都有，所有以下是根据题目应用，代码中有注释，方便理解，ISAP算法就是通过先bfs一遍建立逆序求层数，然后每次都进行维护求最短路来求增广路径，DINIC即是通过顺序，每次找最短路径前都进行一次层次的划分，再来求最短路增广路径，直至无法划分层次出现断层。下面用两个方法来做这道题，可以作为模板使用 题目：http://acm.split.hdu.edu.cn/showproblem
python ac自动机
最新发布
09-02
Python AC自动机是一个用于字符串匹配的算法，它可以高效地在一段文本中查找多个预定义的模式。它的实现可以使用多种库，其中包括ac自动机python和ahocorasick-python。 ac自动机python是一个对标准的ac自动机算法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值