AC自动机题集

最新推荐文章于 2024-03-21 09:37:01 发布
VIP文章 最新推荐文章于 2024-03-21 09:37:01 发布
阅读量1k 收藏 2
点赞数
分类专栏： AC自动机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jinglinxiao/article/details/77888124
版权

AC自动机就是一种在 Trie树上的kmp，用于多模式串的匹配及对多模式串限制的dp。初始时将所有模式串放进Trie树中，然后在Trie树上构建next数组和fail数组。通过next可以进行转移，通过fail可以找到所有具有相同后缀的模式串。有了next数组，Trie树可以看成一个图。在这个图上可以进行各种dp，一般题目上规定了有很多字符串的限制的时候，应该就要想到AC自动机。

HDU-2222

复习AC自动机。

AC自动机是将多个模式串构建成一颗Trie，然后再Trie上构建fail指针。fail指针指向下一个后缀相同的串，复杂度是 O(n) 。

#include<bits/stdc++.h>
using namespace std;
struct Trie
{
    int L,root,nxt[500007][26],end[500007],fail[500007];
    int newnode()
    {
        for(int i=0;i<26;++i)
            nxt[L][i]=-1;
        end[L]=0;
        return L++;
    }
    void init()
    {
        L=0;
        root=newnode();
    }
    void insert(char buf[])
    {
        int len=strlen(buf);
        int now=root;
        for(int i=0;i<len;++i)
        {
            if(nxt[now][buf[i]-'a']==-1)
                nxt[now][buf[i]-'a']=newnode();
            now=nxt[now][buf[i]-'a'];
        }
        ++end[now];
    }
    void build()
    {
        queue<int> q;
        fail[root]=root;
        for(int i=0;i<26;++i)
        {
            if(nxt[root][i]==-1)
                nxt[root][i]=root;
            else
            {
                fail[nxt[root][i]]=root;
                q.push(nxt[root][i]);
            }
        }
        while(!q.empty())
        {
            int now=q.front();
            q.pop();
            for(int i=0;i<26;++i)
            {
                if(nxt[now][i]==-1)
                    nxt[now][i]=nxt[fail[now]][i];
                else
                {
                    fail[nxt[now][i]]=nxt[fail[now]][i];
                    q.push(nxt[now][i]);
                }
            }
        }
    }
    int query(char buf[])
    {
        int len=strlen(buf);
        int tmp,now=root,res=0;
        for(int i=0;i<len;++i)
        {
            now=nxt[now][buf[i]-'a'];
            tmp=now;
            while(tmp!=root)
            {
                res+=end[tmp];
                end[tmp]=0;
                tmp=fail[tmp];
            }
        }
        return res;
    }
};
Trie t;
char s[1000007];
char pt[57];
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n;
        scanf("%d",&n);
        t.init();
        for(int i=0;i<n;++i)
        {
            scanf("%s",pt);
            t.insert(pt);
        }
        t.build();
        scanf("%s",s);
        printf("%d\n",t.query(s));
    }
    return 0;
}

HDU - 2896

set 维护不同的编号

#include<bits/stdc++.h>
using namespace std;
struct Trie
{
    int nxt[100007][128],L,root,fail[100007],end[100007];
    int newnode()
    {
        for(int i=0;i<128;++i)
            nxt[L][i]=-1;
        end[L]=0;
        return L++;
    }
    void init()
    {
        L=0;
        root=newnode();
    }
    void insert(char buf[],int id)
    {
        int len=strlen(buf);
        int now=root;
        for(int i=0;i<len;++i)
        {
            if(nxt[now][buf[i]]==-1)
                nxt[now][buf[i]]=newnode();
            now=nxt[now][buf[i]];
        }
        end[now]=id;
    }
    void build()
    {
        queue<int> q;
        for(int i=0;i<128;++i)
        {
            if(nxt[root][i]==-1)
                nxt[root][i]=root;
            else
            {
                fail[nxt[root][i]]=root;
                q.push(nxt[root][i]);
            }
        }
        while(!q.empty())
        {
            int now=q.front();q.pop();
            for(int i=0;i<128;++i)
            {
                if(nxt[now][i]==-1)
                    nxt[now][i]=nxt[fail[now]][i];
                else
                {
                    fail[nxt[now][i]]=nxt[fail[now]][i];
                    q.push(nxt[now][i]);
                }
            }
        }
    }
    set<int> query(char buf[])
    {
        int len=strlen(buf);
        int now=root,tmp;
        set<int> res;
        for(int i=0;i<len;++i)
        {
            now=nxt[now][buf[i]];
            tmp=now;
            while(tmp!=root)
            {
                if(end[tmp])
                    res.insert(end[tmp]);
                tmp=fail[tmp];
            }
        }
        return res;
    }
};

Trie t;
char pt[207];
char s[10007];
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        t.init();
        for(int i=1;i<=n;++i)
        {
            scanf("%s",pt);
            t.insert(pt,i);
        }
        t.build();
        int m,ans=0;
        scanf("%d",&m);
        for(int i=1;i<=m;++i)
        {
            scanf("%s",s);
            auto res=t.query(s);
            if(res.size())
            {
                ++ans;
                printf("web %d:",i);
                for(auto k : res) printf(" %d",k);
                puts("");
            }
        }
        printf("total: %d\n",ans);
    }
    return 0;
}

HDU-3065

计数。。

#include<bits/stdc++.h>
using namespace std;

int cnt[1007];
struct Trie
{
    int L,root,nxt[50007][128],fail[50007],end[50007];
    int newnode()
    {
        for(int i=0;i<128;++i)
            nxt[L][i]=-1;
        end[L]=0;
        return L++;
    }
    void init()
    {
        L=0;
        root=newnode();
    }
    void insert(string & buf , int id)
    {
        int now=root,len=buf.length();
        for(int i=0;i<len;++i)
        {
            if(nxt[now][buf[i]]==-1)
                nxt[now][buf[i]]=newnode();
            now=nxt[now][buf[i]];
        }
        end[now]=id;
    }
    void build()
    {
        queue<int> q;
        for(int i=0;i<128;++i)
        {
            if(nxt[root][i]==-1)
                nxt[root][i]=root;
            else
            {
                fail[nxt[root][i]]=root;
                q.push(nxt[root][i]);
            }
        }
        while(!q.empty())
        {
            int now=q.front();q.pop();
            for(int i=0;i<128;++i)
            {
                if(nxt[now][i]==-1)
                    nxt[now][i]=nxt[fail[now]][i];
                else
                {
                    fail[nxt[now][i]]=nxt[fail[now]][i];
                    q.push(nxt[now][i]);
                }
            }
        }
    }
    void query(string & buf)
    {
        int len=buf.length(),now=root,tmp;
        for(int i=0;i<len;++i)
        {
            now=nxt[now][buf[i]];
            tmp=now;
            while(tmp!=root)
            {
                ++cnt[end[tmp]];
                tmp=fail[tmp];
            }
        }
    }
};
string pt[1007],s;
Trie t;
int main ()
{
    ios::sync_with_stdio(false);
    int n;
    while(cin >> n)
    {
        t.init();
        memset(cnt,0,sizeof(cnt));
        for(int i=1;i<=n;++i)
        {
            cin >> pt[i];
            t.insert(pt[i],i);
        }
        t.build();
        cin >> s;
        t.query(s);
        for(int i=1;i<=n;++i)
            if(cnt[i])
                cout << pt[i] << ": " << cnt[i] << '\n';
    }
    return 0;
}

ZOJ - 3430

先base64解码后再搞。。有个RE点就是解码后的字符是uchar的。

#include<bits/stdc++.h>
using namespace std;
string b64="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
int f[128];
int buf[100000];
int str[100000],strl;
void decode(string &s)
{
    int len=0;
    for(int i=0;i<s.length();++i)
    {
        if(s[i]=='=')
        {
            len-=(s.length()-i+1)*2;
            break;
        }
        for(int j=0;j<6;++j)
            buf[len+j]=(f[s[i]]>>(6-j-1))&1;
        len+=6;
    }
    strl=0;
    for(int i=0;i<len;i+=8)
    {
        int k=0;
        for(int j=0;j<8;++j)
            k<<=1,k|=buf[i+j];
        str[strl++]=k;
    }
}
struct Trie
{
    int L,root,nxt[40000][256],fail[40000],end[40000],vis[40000];
    int newnode()
    {
        for(int i=0;i<256;++i)
            nxt[L][i]=-1;
        end[L]=vis[L]=0;
        return L++;
    }
    void init()
    {
        L=0;
        root=newnode();
    }
    void insert(int buf[],int len)
    {
        int now=root;
        for(int i=0;i<len;++i)
        {
            if(nxt[now][buf[i]]==-1)
                nxt[now][buf[i]]=newnode();
            now=nxt[now][buf[i]];
        }
        ++end[now];
    }
    void build()
    {
        queue<int> q;
        for(int i=0;i<256;++i)
        {
            if(nxt[root][i]==-1)
                nxt[root][i]=root;
            else
            {
                fail[nxt[root][i]]=root;
                q.push(nxt[root][i]);
            }
        }
        while(!q.empty())
        {
            int now=q.front();q.pop();
            for(int i=0;i<256;++i)
            {
                if(nxt[now][i]==-1)
                    nxt[now][i]=nxt[fail[now]][i];
                else
                {
                    fail[nxt[now][i]]=nxt[fail[now]][i];
                    q.push(nxt[now][i]);
                }
            }
        }
    }
    int query(int buf[],int len ,int id)
    {
        int now=root,tmp,res=0
最低0.47元/天 解锁文章
jinglinxiao
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ac自动机
Insistor
05-29 446
下面开始用图学习ac自动机吧(个人比较喜欢放图,能用一张图解决的绝不叨叨) 首先给定模式串"ash","shex","bcd","sha",然后我们根据模式串建立如下trie树: 然后我们再了解下一步: ac自动机,就是在tire树的基础上,增加一个fail指针,如果当前点匹配失败,则将指针转移到fail指针指向的地方,这样就不用回溯,而可以路匹配下去了.(当前模式串后缀和fail指针指向的...
AC自动机
glorious_dream的博客
03-17 6877
什么是AC自动机？ 能让你自动AC的代码？（显然不是） 1.AC自动机是一种有限状态自动机（说了等于没说），它常被用于多模式串的字符串匹配。 2.在学完AC自动机，笔者也总结出一句说了等于没说的话： AC自动机是以Trie的结构为基础，结合KMP的思想建立的。 （AC = KMP + Trie) 但不完全是。 前置知识：KMP 和Trie。 （很重要） 先说一下如何建AC自动机 1. 基础的Trie结构：将所有的模式串构成一棵Trie树。 2. KMP的思想：对Trie树上所有的结点构造失.
AC自动机经典题目
秋叶红于二月花
05-21 667
如果对AC自动机的概念，比如Trie图，fail树，last树仍有理解上的困难，请参见：AC自动机 一. 多模式匹配 多模式匹配是ac自动机最经典的问题，包括两个优化：构建last树和树上DP，在上面给出的链接中介绍的很详细了，不再赘述。 习题： HDU 2896 HDU 3065 二. AC自动机上DP 常用于给定某些模式串，问类似于以下的问题： 是否存在一个无限长的文本串不包含每个模式串。...
【C++算法模板】AC自动机模板、注释详细、带例题详解
最新发布
qq_63586399的博客
03-21 606
AC自动机是多模式匹配算法，给定n个模式串和一个主串，查找有多少个模式串在主串中出现过。【C++算法模板】字典树，超详细注释带例题讲解-CSDN博客。
C++算法 - AC自动机
LNY2022的博客
05-13 1940
AC自动机用于匹配字符串中的多模式串问题，将所有模式串转换为一个字典树，再用广度优先搜索算法构建出字典树每个结点的失配指针，最后通过搜索主串来匹配主串中包含的模式串个数。
浅谈 AC 自动机
一棵油菜花的OI博客
01-16 1107
省流：比后缀数组还要简单的 AC 自动机！！
ac自动机.pptx
07-14
要学AC自动机需要自备两个前置技能:KMP和trie树(其实个人感觉不会kmp也行,失配指针的概念并不难) 其中,KMP是用于一对一的字符串匹配,而trie虽然能用于多模式匹配,但是每次匹配失败都需要进行回溯,如果模式串很长的话...
AC自动机_AC自动机模板_
09-30
供信息学奥林匹克竞赛选手使用 AC自动机模板
中文高性能AC自动机代码
11-05
C语言实现，效率极高，实现了中文的关键字匹配，输出的格式为偏移量加上关键字（中文编码为GB2312）
AC自动机模板
12-08
AC自动机模板，直接套，有注释N的范围，适合初学者学习
「学习笔记」AC 自动机
Gefangenes的博客
07-24 447
int fail;int tr[26];int End;} ac[N];fail是失配指针，tr是字典树，End是当前状态是否为一个字符串的结束。
AC自动机算法详解以及Java代码实现
终生学习践行者
12-03 2495
详细介绍了AC自动机算法详解以及Java代码实现。
AC自动机套题
莓尊尊strawberry
06-28 204
Keywords Search 题述《 http://acm.hdu.edu.cn/showproblem.php?pid=2222 》 #include<stdio.h> #include<string.h> int next[500057][27]; int fail[500057]; int cnt[500057]; int que[1000057]; int s...
AC自动机（详解）
热门推荐
三季人的博客
09-04 1万+
需要提前了解的知识：KMP, 字典树 例题：传送门 AC自动机是KMP和字典树的结合体， 如果说KMP用于单模式匹配，那么AC自动机是用于多模式匹配的。 举个例子，KMP适用于在一篇文章中找一句话， AC自动机适合在一篇文章中寻找多句话（并不是简单的多用几次KMP）。 KMP算法构建了一个查询表（nex数组）， 我们可以按照相同的思路构建nex表，在ac自动机中成为失配数组。 算法思路： 先将所有的模式串建立字典树， 建立nex数组，然后就开始匹配。 ...
字符串处理【AC自动机】 - 原理 AC自动机详解
谢谢你们的关注
12-08 1281
字符串处理【AC自动机】 - 原理 AC自动机详解
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、付费专栏及课程。

余额充值