AC自动机

最新推荐文章于 2024-06-18 12:51:06 发布
最新推荐文章于 2024-06-18 12:51:06 发布
阅读量99 收藏 1
点赞数
分类专栏： 字符串
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Emma2oo6/article/details/114550293
版权

有什么用：

处理多个字符串的问题

算法实现：

#include<bits/stdc++.h>
using namespace std;
string a[300010];
int num[300010],tr[300010][26],fail[300010],ans[300010];
int tmp,n,cnt;
void insert(string s,int id){
    int now=0;
    for(int i=0;i<s.size();i++){
        int o=s[i]-'a';
        if(!tr[now][o]) tr[now][o]=++cnt;
        now=tr[now][o];
    }
    num[now]=id;
}
void get_fail(){
    int now=0;
    queue<int> q;
    for(int i=0;i<26;i++)
        if(tr[0][i]){
            q.push(tr[0][i]);
            fail[tr[0][i]]=0;
        }
    while(!q.empty()){
        int u=q.front();
        q.pop();
        for(int i=0;i<26;i++){
            int v=tr[u][i];
            if(v){
            	fail[v]=tr[fail[u]][i];
                q.push(v);
            }
            else tr[u][i]=tr[fail[u]][i];
        }
    }
}
void query(string s){
    int now=0;
    for(int i=0;i<s.size();i++){
        now=tr[now][s[i]-'a'];
        for(int j=now;j;j=fail[j])
            ans[num[j]]++;
    }
}
int main(){
    ios::sync_with_stdio(false);
    while(cin>>n&&n){
        memset(num,0,sizeof(num));
        memset(ans,0,sizeof(ans));
        memset(tr,0,sizeof(tr));
        memset(fail,0,sizeof(fail));
        cnt=0;
        for(int i=1;i<=n;i++){
        	cin>>a[i];
        	insert(a[i],i);
        }
        get_fail();
        string k;
        cin>>k;
        query(k);
        tmp=0;
        for(int i=1;i<=n;i++)
            if(ans[i]>tmp) tmp=ans[i];
        cout<<tmp<<"\n";
        for(int i=1;i<=n;i++)
            if(ans[i]==tmp) cout<<a[i]<<"\n";
    }
    return 0;
}

题目：

P3121

#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
const int N=100007;
int ch[N][26], fail[N], val[N], cnt;
queue<int> q;
int n, top, que[N], ans[N];
char p[N], s[N];
void insert(char *s) {
    int len = strlen(s), now = 0;
    for (int i = 0; i < len; ++i) {
        int v = s[i] - 'a';
        if (!ch[now][v]) ch[now][v] = ++cnt;
        now = ch[now][v];
    }
    val[now] = len;
}
void get_fail() {
    for (int i = 0; i < 26; ++i)
        if (ch[0][i]) {
            q.push(ch[0][i]);
            fail[ch[0][i]] = 0;
        }
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (int i = 0; i < 26; ++i)
            if (ch[u][i]) {
                fail[ch[u][i]] = ch[fail[u]][i];
                q.push(ch[u][i]);
            } else ch[u][i] = ch[fail[u]][i];
    }
}
int main() {
    scanf("%s", s);
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) {
        scanf("%s", p);
        insert(p);
    }
    get_fail();
    int len = strlen(s), now = 0;
    for (int i = 0; i < len; ++i) {
        que[i] = now = ch[now][s[i] - 'a'];
        ans[++top] = i;
        if (val[now]) {
            top -= val[now];
            now = que[ans[top]];
        }
    }
    for (int i = 1; i <= top; ++i)
        putchar(s[ans[i]]);
    putchar('\n');
    return 0;
}

P2444

#include<bits/stdc++.h>
using namespace std;
const int N=33333;
int n,ch[N][2],fail[N],cnt;
bool is_word[N],vis[N],ins[N];
char s[N];
void insert(char *s){
    int len=strlen(s),now=0;
    for(int i=0;i<len;i++){
        int x=s[i]-'0';
        if(!ch[now][x]) ch[now][x]=++cnt;
        now=ch[now][x];
    }
    is_word[now]=1;
}
void get_fail(){
    queue<int> q;
    for(int i=0;i<=1;i++){
        if(ch[0][i]) q.push(ch[0][i]); 
    } 
    while(!q.empty()){
        int now=q.front();
        q.pop();
        for(int i=0;i<=1;i++){
            int v=ch[now][i];
            if(v){
                fail[v]=ch[fail[now]][i];
                is_word[v]|=is_word[fail[v]];
                q.push(v); 
            }
            else ch[now][i]=ch[fail[now]][i];
        }
    }
}
void dfs(int now){
    if(ins[now]) puts("TAK"),exit(0);
    if(vis[now]||is_word[now]) return;
    ins[now]=vis[now]=1;
    dfs(ch[now][0]);
    dfs(ch[now][1]);
    ins[now]=0;
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%s",s);
        insert(s);
    }
    get_fail();
    dfs(0);
    puts("NIE");
    return 0;
}

fail tree:

定义：按照AC自动机上fail的反向边建立的树

性质：一棵子树中所有的点都有子树的根这个后缀

应用：一个字符串在T(个体或集合)中出现了多少次

例题：

P2414

/*问题求的是x在y中出现了几次
建出fail tree后，求dfn序，记录每个节点的子树的dfn范围
每出现一个串i，在dfn[i]处+1,每撤销一个串i，在dfn[i]处-1
用树状数组，给节点x的子树求和，乃包含串x的子串个数*/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int N=100010;
struct Edge{
    int u,v,nxt;
}edge[N];
int head[N],cnt;
struct Query{
    int x,y,ans,nxt;
}que[N];
int first[N],quetions;
int ch[N][26],fail[N],val[N],fa[N],vol[N],num,word;
int st[N],ed[N],tot;
int c[N];
char s[N];
int m;
void add_edge(int u,int v){
    edge[++cnt].u=u;
    edge[cnt].v=v;
    edge[cnt].nxt=head[u];
    head[u]=cnt;
}
void add_que(int x,int y){
    que[++quetions].x=x;
    que[quetions].y=y;
    que[quetions].ans=0;
    que[quetions].nxt=first[x];
    first[x]=quetions;
}
void get_fail(){
    queue<int> q;
    for(int i=0;i<26;i++){
        if(ch[0][i]) q.push(ch[0][i]);
    }
    while(!q.empty()){
        int now=q.front();
        q.pop();
        for(int i=0;i<26;i++){
            if(ch[now][i]){
                fail[ch[now][i]]=ch[fail[now]][i];
                q.push(ch[now][i]);
            }
            else ch[now][i]=ch[fail[now]][i];
        }
    }
}
void dfs(int u){
    st[u]=++tot;
    for(int i=head[u];i;i=edge[i].nxt){
        int v=edge[i].v;
        dfs(v);
    }
    ed[u]=tot;
}
void build_fail_tree(){
    for(int i=1;i<=num;i++){
        add_edge(fail[i],i);
    }
    dfs(0);
}
inline int lowbit(int x){return x&(-x);}
void add(int x,int d){
    for(int i=x;i<=N-10;i+=lowbit(i)){
        c[i]+=d;
    }
}
int getsum(int x){
    int ans=0;
    for(int i=x;i>=1;i-=lowbit(i)){
        ans+=c[i];
    }
    return ans;
}
int main(){
    scanf("%s",s);
    int strl=strlen(s),now=0;
    for(int i=0;i<strl;i++){
        if(s[i]=='P'){
            val[now]=1;
            vol[++word]=now;
        }
        else if(s[i]=='B'){
            now=fa[now];
        }
        else{
            int x=s[i]-'a';
            if(!ch[now][x]){
                ch[now][x]=++num;
                fa[ch[now][x]]=now;
            }
            now=ch[now][x];
        }
    }
    get_fail();
    build_fail_tree();
    scanf("%d",&m);
    int x,y;
    for(int i=1;i<=m;i++){
        scanf("%d%d",&x,&y);
        add_que(y,x);
    }
    now=0;word=0;
    for(int i=0;i<strl;i++){
        if(s[i]=='B'){
            add(st[now],-1);
            now=fa[now];
        }
        else if(s[i]=='P'){
            word++;
            for(int j=first[word];j;j=que[j].nxt){
                int l=st[vol[que[j].y]];
                int r=ed[vol[que[j].y]];
                que[j].ans=getsum(r)-getsum(l-1);
            }
        }
        else{
            int x=s[i]-'a';
            now=ch[now][x];
            add(st[now],1);
        }
    }
    for(int i=1;i<=m;i++){
        printf("%d\n",que[i].ans);
    }
    return 0;
}

BZOJ 3881

/*需要注意的是，这里求的是包含x的串的个数，而非x在其中出现的次数
因此在一棵子树里同一种颜色可能有两个，对这棵子树的dfs序贡献必须是1
把当前所有要打上颜色的结点按dfs序排序，每个节点上+1，排序后相邻结点的lca出-1
这样对于一棵子树里的所有颜色相同的结点，它们总的贡献是1*/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
const int N=2000003;
struct Edge{
    int nxt,to;
}edge[N];
int id[N],ch[N][26],fail[N],cnt2=1,head[N],cnt;
void add_edge(int u, int v){
    edge[++cnt]=(Edge){head[u],v}; 
    head[u]=cnt;
}
void insert(char *s,int num){
    int x,now=1,len=strlen(s);
    for(int i=0;i<len;i++){
        x=s[i]-'a';
        if(ch[now][x]!= 0) now=ch[now][x];
        else now=ch[now][x]=++cnt2;
    }
    id[num]=now;
}
void get_fail(){
    queue<int> q;
    q.push(1);
    while(!q.empty()) {
        int x=q.front();
        q.pop();
        for (int i = 0; i < 26; ++i)
            if(ch[x][i]){
                int v=ch[x][i];
                int f=fail[x];
                while(f&&ch[f][i]==0)
                    f=fail[f];
                fail[v]=f?ch[f][i]:1;
                q.push(v);
                add_edge(fail[v],v);
            }
    }
}
int n,tot=0,deep[N],st[N],ed[N],sz[N],top[N],son[N],fa[N];
char s[N];
void dfs(int x) {
    st[x]=++tot; 
    sz[x]=1;
    for(int i=head[x];i;i=edge[i].nxt) {
        int v=edge[i].to;
        fa[v]=x; 
        deep[v]=deep[x]+1;
        dfs(v); 
        sz[x]+=sz[v];
        if(son[x]==0||sz[v]>sz[son[x]])
            son[x]=v;
    }
    ed[x] = tot;
}
void dfs2(int x) {
    if(son[x]){
        top[son[x]]=top[x];
        dfs2(son[x]);
    }
    for(int i=head[x];i;i=edge[i].nxt){
        int v=edge[i].to;
        if(v!=son[x])
            top[v]=v,dfs2(v);
    } 
}
int LCA(int x,int y){
    while(top[x]!=top[y]) {
        if(deep[top[x]]<deep[top[y]])
            swap(x, y);
        x=fa[top[x]];
    }
    return deep[x]<deep[y]?x:y;
}
bool cmp(int x,int y){
    return st[x]<st[y];
}
int bits[N],a[N];
void update(int x, int d) {
    for (;x<=tot;x+=(x&(-x)))
        bits[x]+=d;
}
int sum(int x) {
    int ret=0;
    for (;x;x-=(x&(-x)))
        ret+=bits[x];
    return ret;
}
void add(char *s){
    int len=strlen(s),x,now=1,tt=0;
    for (int i=0;i<len;i++){
        x=s[i]-'a';
        if(ch[now][x]) now=ch[now][x];
        else{
            while(now&&ch[now][x]== 0) now=fail[now];
            if(ch[now][x]) now=ch[now][x];
            else now=1;
        }
        a[++tt]=now;
        update(st[now],1);
    }
    sort(a+1,a+tt+1,cmp);
    for (int i=2;i<=tt;i++)
        update(st[LCA(a[i-1],a[i])],-1);
}
int Sum(int x) {
    return sum(ed[x])-sum(st[x]-1);
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%s",s);
        insert(s,i);
    }
    get_fail();
    dfs(1);
    top[1]=1; 
    dfs2(1);
    int q,opt;
    scanf("%d",&q);
    while(q--){
        scanf("%d",&opt);
        if(opt==1) {
            scanf("%s",s);
            add(s);
        } 
        else{
            scanf("%d",&opt);
            printf("%d\n",Sum(id[opt]));
        }
    }
    return 0;
}

DP：

大部分f[i][j]表示当前在节点j,且串长为i时的情况

有时再加一维表示这个状态里面包含了哪些东西

题目：

P4052

//正难则反
#include<bits/stdc++.h>
using namespace std;
const int mod=10007;
const int N=100005;
int ch[N][26],fail[N],is[N];
int n,m,cnt,sum,ans,f[105][N];//f[i][j]表示当前在j点且串长为i时不经过单词结尾的路径条数
char s[N];
void insert(char *s){
    int len=strlen(s),now=0;
    for(int i=0;i<len;i++){
        int x=s[i]-'A';
        if(!ch[now][x]) ch[now][x]=++cnt;
        now=ch[now][x];
    }
    is[now]|=1;
}
void get_fail(){
    queue<int> q;
    for(int i=0;i<26;i++){
        if(ch[0][i]) q.push(ch[0][i]); 
    }
    while(!q.empty()){
        int now=q.front();
        q.pop();
        for(int i=0;i<26;i++){
            if(!ch[now][i]){
                ch[now][i]=ch[fail[now]][i];
                continue;
            }
            is[ch[now][i]]|=is[ch[fail[now]][i]];
            fail[ch[now][i]]=ch[fail[now]][i];
            q.push(ch[now][i]);
        }
    }
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%s",s);
        insert(s);
    }
    get_fail();
    f[0][0]=1;
    for(int i=1;i<=m;i++){
        for(int j=0;j<=cnt;j++){
            for(int k=0;k<26;k++){
                if(!is[ch[j][k]])
                    f[i][ch[j][k]]+=f[i-1][j]%=mod;
            }
        }
    }
    for(int i=0;i<=cnt;i++)
        (ans+=f[m][i])%=mod;
    int sum=1;
    for(int i=1;i<=m;i++)
        sum=sum*26%mod;
    printf("%d",(sum-ans+mod)%mod);
    return 0;
}

P3041

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int N=510;
int ch[N][3],fail[N],num[N],cnt;
int n,k,dp[1005][N],vis[1005][N];
char s[N];
void insert(char *s){
    int len=strlen(s),now=0;
    for(int i=0;i<len;i++){
        int x=s[i]-'A';
        if(!ch[now][x]) ch[now][x]=++cnt;
        now=ch[now][x];
    }
    num[now]++; 
}
void get_fail(){
    queue<int> q;
    for(int i=0;i<3;i++){
        if(ch[0][i]) q.push(ch[0][i]);
    }
    while(!q.empty()){
        int now=q.front();
        q.pop();
        for(int i=0;i<3;i++){
            int v=ch[now][i];
            if(v) fail[v]=ch[fail[now]][i],q.push(v);
            else ch[now][i]=ch[fail[now]][i];
        }
    }
}
int cal(int now,int val){
    while(now){
        val+=num[now];
        now=fail[now];
    }
    return val;
}
int main(){
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;i++){
        scanf("%s",s);
        insert(s);
    }
    get_fail();
    vis[0][0]=1;
    for(int i=0;i<k;i++){
        for(int j=0;j<=cnt;j++){
            if(!vis[i][j]) continue;
            for(int x=0;x<3;x++){
                int now=ch[j][x];
                dp[i+1][now]=max(dp[i+1][now],cal(now,dp[i][j]));
                vis[i+1][now]=1;
            }
        }
    }
    int ans=0;
    for(int i=0;i<=cnt;i++)
        ans=max(dp[k][i],ans);
    printf("%d\n",ans);
    return 0;
}
Edward The Bunny
关注
专栏目录
36丨AC自动机：如何用多模式串匹配实现敏感词过滤功能？1
08-03
AC自动机是一种高效的多模式串匹配算法，主要应用于文本处理中的敏感词过滤、关键词搜索等功能。它的全称为Aho-Corasick算法，由Aho和Corasick在1975年提出。AC自动机在Trie树的基础上进行了扩展，增加了失败指针，...
AC 自动机
orz
08-25 1362
AC 自动机 引入 AC 自动机是一种用于解决多模式串以及一主串匹配的字符串算法。 问题通常是给出若干个模式串 S 以及主串 T，询问若干个模式串分别在主串中的某些信息。 AC 自动机构建在 Trie 的结构基础上，结合了 KMP 算法的失配指针思想。 在进行多模式串匹配前，只有两个步骤需要去实现： 将所有模式串扔进一棵 Trie 树中。 对于 Trie 上的所有节点构建失配指针。 AC 自动机的时间复杂度约为 O(n+m)O(n+m)O(n+m)。 算法思想 AC 自动机其实就是在 Trie
关于 AC 自动机
weixin_43501634的博客
02-22 3321
AC 自动机，全称 Aho-Corasick 自动机，是一种用于字符串搜索的算法，由 Alfred V. Aho 和 Margaret J. Corasick 在 1975 年提出。这个算法是为了解决在一个主文本字符串中查找多个模式字符串（或称为“关键词”）的问题，它可以在线性时间内完成搜索，非常高效。在计算机科学中，Aho-Corasick 算法是 Alfred V. Aho 和 Margaret J. Corasick 于 1975 年发明的一种字符串搜索算法。
ac自动机
weixin_42593130的博客
01-03 243
AC自动机(英语：Aho-Corasick algorithm)是一种用于在文本串中快速搜索多个模式串的算法。它的名字来源于其发明者Alfred V. Aho和Margaret J. Corasick。AC自动机是一种多模式匹配算法，通常被用于在大型文本串或网络流中搜索多个模式串。它的时间复杂度是O(n+m+z)，其中n是文本串的长度，m是模式串的总长度，z是匹配次数。AC自动机在许多文本编辑器和...
数据结构与算法笔记：基础篇 -AC自动机：如何用多模式串匹配实现敏感词过滤功能？
chenjian723122704的专栏
06-18 726
很多支持用户发表文本内容的网站，比如 BBS，大都会有敏感词过滤功能，用来过滤掉用户输入的一些淫秽、反动、谩骂等内容。你有没有想过，这个功能是怎么实现的呢？实际上，这些功能最基本的原理就是字符串匹配算法，也就是通过维护一个敏感词字典，当用户输入一段文字内容之后，通过字符串匹配算法，来查找用户输入的这段文字，是否包含敏感词。如果有，就用 “***” 把它替换掉。我们讲过讲过好几种字符串匹配算法了，它们都可以处理这个问题。但是，对于访问量巨大的网站来说，比如淘宝，用户每天的评论数有几亿、甚至十几亿。
AC自动机算法
懒猫的脚印
08-15 1328
ac自动机，双数组
ac自动机详解
dajiangyou123456的博客
01-27 336
转自大佬的blog：https://www.cnblogs.com/cmmdc/p/7337611.html 简介： 首先简要介绍一下AC自动机：Aho-Corasick automation，该算法在1975年产生于贝尔实验室，是著名的多模匹配算法之一。一个常见的例子就是给出n个单词，再给出一段包含m个字符的文章，让你找出有多少个单词在文章里出现过。要搞懂AC自动机，先得有模式树（字典树）Tri...
java ac自动机_Java实现AC自动机全文检索示例
weixin_42488997的博客
02-23 387
第一步，构建Trie树，定义Node类型：/*** Created by zhaoyy on 2017/2/7.*/interface Node {char value();boolean exists();boolean isRoot();Node parent();Node childOf(char c);Node fail();void setFail(Node node);void set...
AC自动机_AC自动机模板_
09-30
AC自动机，全称为Aho-Corasick自动机，是一种字符串搜索算法，广泛应用于信息学奥林匹克竞赛、数据结构与算法竞赛以及文本处理等领域。它的主要功能是高效地在一个字符串集合中进行多模式匹配，即同时查找多个模式串...
高效Java敏感词过滤系统AC自动机算法源码，支持独立部署与集成注册中心
03-25
本项目是一款高效的Java敏感词过滤系统，基于AC自动机算法实现。系统支持独立部署，同时可便捷集成至注册中心，为各类项目提供敏感词过滤服务。包含文件共117个，其中主要构成如下： - Java源文件：49个 - Class...
ahocorasick-python:AC自动机python的实现，并进行了优化。 主要修复了 查询不准确的问题
05-18
ac自动机python的实现，可用于python2 python3等主流python发行版，对标准的ac自动机算法进行了完善 优化(主要是改进了结果的准确性)。 注意：为了保证结果的准确性，请安装使用最新版(0.0.9)。 1.如何安装 pip 安装...
numcodecs-0.10.0-cp39-cp39-win_amd64.whl
10-19
numcodecs-0.10.0-cp39-cp39-win_amd64.whl
【BP时序预测】基于雾凇优化算法RIME-BP实现负荷数据预测单输入单输出附matlab代码.rar
10-20
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
【JCR一区级】Matlab实现北方苍鹰优化算法NGO-CNN-BiLSTM-Attention的故障诊断算法研究.rar
最新发布
10-20
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
双碳数字化平台及场景应用解决方案（28页 PPT）.pptx
10-19
双碳数字化平台及场景应用解决方案（28页 PPT）
低级编程语言汇编的特性, 项目案例及应用场景
10-19
汇编语言 内容概要：本文详细介绍了汇编语言的特点、应用场景及其编写示例。汇编语言是一种低级编程语言，使用助记符来代表机器指令，与硬件紧密结合，执行效率高但可读性差。常见应用场景包括操作系统内核、设备驱动程序、嵌入式系统、性能优化等领域。 适用人群：软件开发人员，特别是对底层编程感兴趣的开发人员。 使用场景及目标：了解汇编语言的基本概念和特点；学习在操作系统内核、设备驱动程序、嵌入式系统、性能优化等场景中使用汇编语言的方法和技巧；掌握汇编语言的基础知识和编程工具。 其他说明：文章还提供了学习汇编语言的方法和资源，帮助初学者快速入门。
数学建模模板 华为杯，高教杯
10-19
数学建模模板 华为杯，高教杯
AC自动机算法：高效字符串匹配
"AC自动机.pdf" AC自动机（Aho-Corasick Algorithm）是一种用于高效处理字符串精确匹配问题的算法，特别适用于在一个大的文本（目标串T）中查找多个模式串（模式串集合P）的情况。它的时间复杂度为O(n+m+z)，其中n...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值