AC自动机-题目集合

最新推荐文章于 2025-06-19 17:50:42 发布
最新推荐文章于 2025-06-19 17:50:42 发布
阅读量1.7k 收藏 3
点赞数 2
CC 4.0 BY-SA版权
分类专栏： 模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WR_technology/article/details/52782182

 AC自动机-题目集合 模板

  如果你想要学习AC自动机,推荐一些学习资料.

学习可以看这篇博客 http://blog.csdn.net/niushuai666/article/details/7002823

或者看看大佬的视频讲解 http://www.bilibili.com/video/av6295004/

下面是一些AC自动机的一些入门题目.和AC代码,先学再做练习.


题目链接: hdu-2222

#include<cstdio>
#include<cstring>
#include<cctype>
#include<cmath>
#include<set>
#include<map>
#include<list>
#include<queue>
#include<deque>
#include<stack>
#include<string>
#include<vector>
#include<iostream>
#include<algorithm>
#include<stdlib.h>
#include<time.h>

using namespace std;
typedef long long LL;
const int INF=2e9+1e8;
const int MOD=1e9+7;
const int MAXSIZE=1e6+5;
const double eps=0.0000000001;
void fre()
{
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
}
#define memst(a,b) memset(a,b,sizeof(a))
#define fr(i,a,n) for(int i=a;i<n;i++)

const int MAXNode=5e5+5;
struct Aho
{
    int ch[MAXNode][26]; // 多模式字符串 需要构建的 Tire(字典树)
    int last[MAXNode];   //  统计某一个模式串 (在Tire中MaxNode位置结尾的字符串) 个数,
    int fail[MAXNode]; //失配指针
    int sz,root;
    int newnode()
    {
        memset(ch[sz],-1,sizeof(ch[sz]));
        last[sz++]=0;
        return sz-1;
    }
    void init()
    {
        sz=0;
        root=newnode();
    }
    void insert(char *s)
    {
        int len=strlen(s);
        int now=root;
        for(int i=0; i<len; i++)
        {
            if(ch[now][s[i]-'a']==-1) ch[now][s[i]-'a']=newnode();
            now=ch[now][s[i]-'a'];
        }
        last[now]++;
    }
    void GetFail()// 如何构建失败指针,还是不太会.所以套 kuangbin 模板
    {
        queue<int>Q;
        fail[root]=root;
        for(int i = 0; i < 26; i++)
        {
            if(ch[root][i]==-1)
                ch[root][i]=root;
            else
            {
                fail[ch[root][i]]=root;
                Q.push(ch[root][i]);
            }
        }
        while(!Q.empty())
        {
            int now=Q.front();
            Q.pop();
            for(int i=0; i<26; i++)
            {
                if(ch[now][i]==-1)
                    ch[now][i]=ch[fail[now]][i];
                else
                {
                    fail[ch[now][i]]=ch[fail[now]][i];
                    Q.push(ch[now][i]);
                }
            }
        }
    }
    int match(char *s)
    {
        int len=strlen(s);
        int now=root;
        int res=0;
        for(int i=0; i<len; i++)
        {
            now=ch[now][s[i]-'a'];
            int temp=now;
            while(temp!=root)
            {
                res+=last[temp];
                last[temp]=0;
                temp=fail[temp];
            }
        }
        return res;
    }
} ac;
char str[MAXSIZE];
inline void read(int& ret) //适用于正整数
{
    char c;
    ret=0;
    while((c=getchar())<'0'||c>'9');
    while(c>='0'&&c<='9') ret=ret*10+(c-'0'),c=getchar();
}
int main(int argc,char *argv[])
{
    int ncase;
    read(ncase);
    while(ncase--)
    {
        int n;
        ac.init();
        scanf("%d",&n);
        for(int i=0; i<n; i++)
        {
            scanf("%s",str);
            ac.insert(str);
        }
        ac.GetFail();
        scanf("%s",str);
        printf("%d\n",ac.match(str));
    }
    return 0;
}

/**  http://blog.csdn.net/wr_technology  */


鄙人只是存模板,失配指针怎么构建,目前正在学习之中。若想要学习 AC自动机。请点这篇博文。总结的详细。


------------------------------------------  分割线  ---------------------------------------------------------


上面是kuangbin模板,不太会。因为他在构建fail指针的的时候不是最简单的方法。所以我又找了一另一个代码来学习,这一份就是朴素的方法,不像kuangbin模板优化过,不适合初学者。


#include<cstdio>
#include<cstring>
#include<cctype>
#include<cmath>
#include<set>
#include<map>
#include<list>
#include<queue>
#include<deque>
#include<stack>
#include<string>
#include<vector>
#include<iostream>
#include<algorithm>
#include<stdlib.h>
#include<time.h>

using namespace std;
typedef long long LL;
const int INF=2e9+1e8;
const int MOD=1e9+7;
const int MAXSIZE=1e6+5;
const double eps=0.0000000001;
void fre()
{
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
}
#define memst(a,b) memset(a,b,sizeof(a))
#define fr(i,a,n) for(int i=a;i<n;i++)

const int MAXNode=5e5+5;
struct Aho
{
    int ch[MAXNode][26]; // 多模式字符串 需要构建的 Tire(字典树)
    int last[MAXNode];   //  统计某一个模式串 (在Tire中MaxNode位置结尾的字符串) 个数,
    int fail[MAXNode]; //失配指针
    int sz,root;
    int newnode()
    {
        memset(ch[sz],-1,sizeof(ch[sz]));
        last[sz++]=0;
        return sz-1;
    }
    void init()
    {
        sz=0;
        root=newnode();
    }
    void insert(char *s)
    {
        int len=strlen(s);
        int now=root;
        for(int i=0; i<len; i++)
        {
            if(ch[now][s[i]-'a']==-1) ch[now][s[i]-'a']=newnode();
            now=ch[now][s[i]-'a'];
        }
        last[now]++;
    }
    void GetFail()//
    {
        queue<int>Q;
        Q.push(root);
        while(!Q.empty())
        {
            int now=Q.front();
            Q.pop();
            for(int i=0;i<26;i++)
            {
                if(ch[now][i]!=-1)
                {
                    if(now==root) fail[ch[now][i]]=root;
                    else
                    {
                        int temp=fail[now];
                        while(temp&&ch[temp][i]==-1) temp=fail[temp];
                        fail[ch[now][i]]=ch[temp][i];
                    }
                    Q.push(ch[now][i]);
                }
            }
        }
        return ;
    }
    int match(char *s)
    {
        int len=strlen(s);
        int now=root,temp;
        int res=0;
        for(int i=0; i<len; i++)
        {

            while(now&&ch[now][s[i]-'a']==-1) 
                now=fail[now];temp=now=ch[now][s[i]-'a'];
            while(temp!=root)
            {
                res+=last[temp];
                last[temp]=0;
                temp=fail[temp];
            }
        }
        return res;
    }
} ac;
char str[MAXSIZE];
inline void read(int& ret)
{
    char c;
    ret=0;
    while((c=getchar())<'0'||c>'9');
    while(c>='0'&&c<='9') ret=ret*10+(c-'0'),c=getchar();
}
int main(int argc,char *argv[])
{
    int ncase;
    read(ncase);
    while(ncase--)
    {
        int n;
        ac.init();
        scanf("%d",&n);
        for(int i=0; i<n; i++)
        {
            scanf("%s",str);
            ac.insert(str);
        }
        ac.GetFail();
        scanf("%s",str);
        printf("%d\n",ac.match(str));
    }
    return 0;
}

/**  http://blog.csdn.net/wr_technology  */

------------------------------------------------------------------------------------------------------------------------------------------------------------

下面是 hdu-2896 

#include<cstdio>
#include<cstring>
#include<cctype>
#include<cmath>
#include<set>
#include<map>
#include<list>
#include<queue>
#include<deque>
#include<stack>
#include<string>
#include<vector>
#include<iostream>
#include<algorithm>
#include<stdlib.h>
#include<time.h>
using namespace std;
typedef long long LL;
const int INF=2e9+1e8;
const int MOD=1e9+7;
const int MAXSIZE=1e6+5;
const double eps=0.0000000001;
void fre()
{
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
}
#define memst(a,b) memset(a,b,sizeof(a))
#define fr(i,a,n) for(int i=a;i<n;i++)
const int MAXNode=5e5+5;


int ans[10005][505],cnt[505];
struct Aho
{
    int ch[100000][128]; // 多模式字符串 需要构建的 Tire(字典树)
    int last[MAXNode];   //  统计某一个模式串 (在Tire中MaxNode位置结尾的字符串) 个数,
    int fail[MAXNode]; //失配指针
    int sz,root;
    int newnode()
    {
        memset(ch[sz],-1,sizeof(ch[sz]));
        last[sz++]=0;
        return sz-1;
    }
    void init()
    {
        sz=0;
        root=newnode();
    }
    void insert(char *s,int id)
    {
        int now=root;
        for(int i=0;  s[i]!='\0' ; i++)
        {
            if(ch[now][(int)s[i]]==-1) ch[now][(int)s[i]]=newnode();
            now=ch[now][(int)s[i]];
        }
        last[now]=id;
    }
    void GetFail()
    {
        queue<int>Q;
        Q.push(root);
        while(!Q.empty())
        {
            int now=Q.front();
            Q.pop();
            for(int i=0; i<128; i++)
            {
                if(ch[now][i]!=-1)
                {
                    if(now==root) fail[ch[now][i]]=root;
                    else
                    {
                        int temp=fail[now];
                        while(temp&&ch[temp][i]==-1) temp=fail[temp];
                        fail[ch[now][i]]=ch[temp][i];
                    }
                    Q.push(ch[now][i]);
                }
            }
        }
        return ;
    }
    void match(char *s,int id)
    {
        int  flag[550];
        memset(flag,0,sizeof(flag));
        int now=root,temp;
        for(int i=0; s[i]!='\0'; i++)
        {

            while(now&&ch[now][(int)s[i]]==-1)
                now=fail[now];
            temp=now=ch[now][(int)s[i]];
            while(temp!=root&&flag[last[temp]]==0)
            {
                if(last[temp])
                {
                    ans[id][cnt[id]++]=last[temp];
                    flag[last[temp]]=1;
                }
                temp=fail[temp];
            }
            if(cnt[id]>=3) break;
        }
        return ;
    }
} ac;
char str[MAXSIZE];
void print(int m)
{
    int sum=0;
    for(int i=1; i<=m; i++)
    {
        if(!cnt[i]) continue;
        printf("web %d:",i);
        for(int j=0; j<cnt[i]; j++) printf(" %d",ans[i][j]);
        printf("\n");
        sum++;
    }
    printf("total: %d\n",sum);
}

int main(int argc,char *argv[])
{
    int n,m;
    scanf("%d",&n);
    getchar();
    memset(cnt,0,sizeof(cnt));
    ac.init();
    for(int i=1; i<=n; i++)
    {
        gets(str);
        ac.insert(str,i);
    }
    ac.GetFail();
    scanf("%d",&m);
    getchar();
    for(int j=1; j<=m; j++)
    {
        scanf("%s",str);
        ac.match(str,j);
        sort(ans[j],ans[j]+cnt[j]);
    }
    print(m);
    return 0;
}

-----------------------------------------------------------------------------------------------------------------------


hihocoder-1036

#include<cstdio>
#include<cstring>
#include<cctype>
#include<cmath>
#include<set>
#include<map>
#include<list>
#include<queue>
#include<deque>
#include<stack>
#include<string>
#include<vector>
#include<iostream>
#include<algorithm>
#include<stdlib.h>
#include<time.h>

using namespace std;
typedef long long LL;
const int INF=2e9+1e8;
const int MOD=1e9+7;
const int MAXSIZE=1e6+5;
const double eps=0.0000000001;
void fre()
{
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
}
#define memst(a,b) memset(a,b,sizeof(a))
#define fr(i,a,n) for(int i=a;i<n;i++)

const int MAXNode=5e6+5;

struct Aho
{
    int ch[MAXNode][26],fail[MAXNode],last[MAXNode],root,sz;
    int newnode()
    {
        memset(ch[sz],-1,sizeof(ch[sz]));
        last[sz++]=0;
        return sz-1;
    }
    void init()
    {
        sz=0;
        root=newnode();
    }
    void insert(char *s)
    {
        int now=root;
        for(int i=0; s[i]!='\0'; i++)
        {
            int id=(int)(s[i]-'a');
            if(ch[now][id]==-1) ch[now][id]=newnode();
            now=ch[now][id];
        }
        last[now]=1;
    }
    void GetFail()
    {
        queue<int>Q;
        fail[root]=root;
        Q.push(root);
        while(!Q.empty())
        {
            int now=Q.front();
            Q.pop();
            for(int i=0; i<26; i++)
            {
                if(now==root)
                {
                    if(ch[now][i]==-1) ch[now][i]=root;
                    else fail[ch[now][i]]=root,Q.push(ch[now][i]);
                }
                else
                {
                    if(ch[now][i]==-1) ch[now][i]=ch[fail[now]][i];
                    else fail[ch[now][i]]=ch[fail[now]][i],Q.push(ch[now][i]);
                }
            }
        }
    }
    bool match(char *s)
    {
        int now=root;
        for(int i=0; s[i]!='\0'; i++)
        {
            now=ch[now][(int)(s[i]-'a')];
            if(last[now]) return true;
        }
        return false;
    }
} ac;
char str[MAXSIZE];
int main()
{
    int n;
    cin>>n;
    ac.init();
    for(int i=0; i<n; i++)
    {
        scanf("%s",str);
        ac.insert(str);
    }
    scanf("%s",str);
    ac.GetFail();
    if(ac.match(str)) cout<<"YES"<<endl;
    else cout<<"NO"<<endl;
    return 0;
}





AC自动机算法概述及习题
lucius-liu.cn
09-25 1587
AC 自动机主要适用于多个模式串下的匹配问题，常嵌套 dp 进行考察或者利用其 fail 树的性质进行出题。但是这些问题都有一个相同的特点，就是一定会题目给出或者人为建出多个字符串进行匹配，此点可以用于辨别 AC 自动机问题。
AC自动机初步入门详解
weixin_43888067的博客
09-28 653
前言 AC自动机（Aho-Corasick automaton）是KMP的升级版。KMP是单模匹配算法，处理在一个文本串中查找一个模式串的问题；AC自动机是多模匹配算法，能在一个文本串中同时查找多个不同的模式串。 多模块匹配问题：给定一个长度为n的文本S，以及k个平均长度为m的模式串P1,P2,…,Pn，要求搜索这些模式串出现的位置。 其实用KMP也能解决多模匹配问题，缺点是复杂度较高，需要对每个...
AC自动机（模板+例题）
等我，等我变的更好就去找你
06-12 1537
首先要明白AC自动机是干什么的： AC自动机其实就是一种多模匹配算法，那么你可能会问什么叫做多模匹配算法。下面是我对多模匹配的理解，与多模与之对于的是单模，单模就是给你一个单词，然后给你一个字符串，问你这个单词是否在这个字符串中出现过（匹配），这个问题可以用kmp算法在比较高效的效率上完成这个任务。那么现在我们换个问题，给你很多个单词，然后给你一段字符串，问你有多少个单词在这个字符串中出现...
字符串匹配与文本处理（七）：AC自动机
最新发布
一碗黄焖鸡三碗米饭的博客
06-19 601
本文深入解析了AC自动机(Aho-Corasick Automaton)这一高效的多模式字符串匹配算法。文章首先介绍了AC自动机的核心概念，包括字典树(Trie)和失败指针的实现原理。随后详细阐述了其工作原理，分为预处理阶段(构建字典树和失败指针)和匹配阶段，并分析了O(n)的时间复杂度优势。通过完整的Java代码实现，展示了如何定义字典树节点、构建失败指针以及执行文本匹配。最后，将AC自动机与其他字符串匹配算法(KMP、Boyer-Moore等)进行对比，突出其在多模式匹配场景中的高效性。本文为理解AC自
AC自动机总结
热门推荐
小白菜又菜
03-30 2万+
AC自动机总结 0.引言：       由于大连现场赛的一道 AC自动机+ DP的题目(zoj3545 Rescue the Rabbit)被小媛同学推荐看 AC自动机。经过一段时间的努力，终于把 shǎ崽神牛的 AC自动机专辑题目 AK(其实还差那个高中题。。囧。。不让做)。       特别感谢：shǎ崽神牛，并附以链接：       http://www.notonlys
AC自动机模板及基础例题小结
AZRAEL_DEATH
06-27 1007
AC自动机(Aho-Corasick Automation)
AC自动机习题集
天亮说晚安
07-21 3542
@notonlysuccess http://www.cs.uku.fi/~kilpelai/BSA05/lectures/slides04.pdf http://www.docin.com/p-46845432.html(上边原文地址如果无法访问的话可以访问这一个~) 这是我找到的AC自动机最好的资料 感觉网上其他一些资料都没能阐述的很好，只是草草的介绍一下fail指针，画几张草图而已，
AC自动机题解1
08-03
在这个题目中，AC自动机被用来解决DNA序列的问题。通过构建AC自动机，可以快速找出目标DNA片段中与致病DNA片段匹配的部分。然后通过动态规划（DP）方法，计算最少需要改变多少个碱基以避免匹配到任何致病片段。这里...
字符串 KMP算法与AC自动机算法
07-20 477
文章目录KMP题目集亲和串PeriodNumber Sequence KMP 题目集 亲和串 亲和串 题目大意 人随着岁数的增长是越大越聪明还是越大越笨，这是一个值得全世界科学家思考的问题,同样的问题Eddy也一直在思考，因为他在很小的时候就知道亲和串如何判断了，但是发现，现在长大了却不知道怎么去判断亲和串了，于是他只好又再一次来请教聪明且乐于助人的你来解决这个问题。 亲和串的定义是这样的：给定两个字符串s1和s2,如果能通过s1循环移位，使s2包含在s1中，那么我们就说s2 是s1的亲和串。 Input
字符串处理算法详解：Hash、KMP、字典树、AC自动机与后缀数组
"这篇资料主要介绍了字符串处理算法，包括Hash、KMP、字典树、AC自动机和后缀数组等方法，适用于ACM/ICPC竞赛训练。内容涵盖Hash算法的基本思想、冲突解决策略，如Rabin-Karp算法以及Java中的HashMap应用，并给出了...
AC自动机详解+例题详解
10-25
关于AC自动机的详细的讲解+标程，还有一些例题的讲解。
AC自动机 入门练习题
nefu_ljw的博客
05-21 1263
洛谷日报 强势图解AC自动机 https://www.luogu.com.cn/blog/3383669u/qiang-shi-tu-xie-ac-zi-dong-ji AC自动机-多模式匹配算法 https://blog.csdn.net/xaiojiang/article/details/52299258 AC 自动机 - OI Wiki https://oi-wiki.org/string/ac-automaton/ ...
AC自动机：例题与机制详解
BUG_Creater_jie的博客
03-21 229
介绍 AC自动机是kmp算法和trie树的结合 大体就是做这样的题用： 可以发现，这题和trie树的区别是把多个单词往一篇文章匹配，而trie恰好相反 匹配的时候其实就是判断子串，所以又用到了kmp 定义失配指针nxt[i]：表示root到nxt[i]结点的字符串是到nxt[i]结点的字符串的在本树中的最长后缀（其实和kmp差不多啦） 设文章下一个字是s，当前trie树结点是a 每次发现a结点下方没有s的儿子~~（膝下无子）~~ 就回去重新找失配指针 现在考虑处理失配指针 因为显然nxt[i]的深度小于i
AC自动机经典题目
秋叶红于二月花
05-21 759
如果对AC自动机的概念，比如Trie图，fail树，last树仍有理解上的困难，请参见：AC自动机 一. 多模式匹配 多模式匹配是ac自动机最经典的问题，包括两个优化：构建last树和树上DP，在上面给出的链接中介绍的很详细了，不再赘述。 习题： HDU 2896 HDU 3065 二. AC自动机上DP 常用于给定某些模式串，问类似于以下的问题： 是否存在一个无限长的文本串不包含每个模式串。...
AC自动机总结 与模板题
liujc_的专栏
03-19 903
参考学习资料：http://blog.csdn.net/niushuai666/article/details/7002823 学会trie树和kmp算法后就可以学习ac自动机了。 ac自动机可以用于多个模式串的匹配问题上。比如考虑在一个文本中出现了几个所给出的模式串。 整个结构大致跟trie树一样，不过多加了个fail指针，这个思想跟KMP算法是类似的，就是防止主串的回退，使当前字符失配时跳
AC自动机算法及模板
楠先生
05-08 6713
关于AC自动机 AC自动机：Aho-Corasickautomation，该算法在1975年产生于贝尔实验室，是著名的多模匹配算法之一。一个常见的例子就是给出n个单词，再给出一段包含m个字符的文章，让你找出有多少个单词在文章里出现过。要搞懂AC自动机，先得有模式树（字典树）Trie和KMP模式匹配算法的基础知识。AC自动机算法分为3步：构造一棵Trie树，构造失败指针和模式匹配过
AC自动机练习题
lb2003
08-20 379
caioj1465 【题意】 给出有一个L∗CL*CL∗C的字符地图，地图的行与列都从000开始编号 然后给出一些字符串，求出这些字符串在字符地图上的位置。（数据保证有唯一解） 输出字符串第一个字母的坐标和字符串的方向 字符串的方向是指字符串的走向 A表示正北，B表示东北，C表示正东，D表示东南，E表示正南，F表示西南，G表示正西，H表示西北 且保证字符串的方向是固定的 【输入格式】 第一行输入L...
AC自动机题集
On the way
09-07 1091
AC自动机就是一种在 Trie树上的kmp，用于多模式串的匹配及对多模式串限制的dp。初始时将所有模式串放进Trie树中，然后在Trie树上构建next数组和fail数组。通过next可以进行转移，通过fail可以找到所有具有相同后缀的模式串。有了next数组，Trie树可以看成一个图。在这个图上可以进行各种dp，一般题目上规定了有很多字符串的限制的时候，应该就要想到AC自动机。HDU-2222复习
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值