AC自动机

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

关于AC自动机，http://www.cnblogs.com/kuangbin/p/3164106.html这个博客讲的非常清楚。

AC自动机基本就是trie和kmp的结合，实现起来也没有特别麻烦的细节，比kmp甚至还好写。关于next数组和fail数组，fail数组就是kmp中的next数组，只不过fail数组是针对很多组字符串而kmp中的next只有一个字符串。AC自动机中的fail数组在查询过程中完全没有用到，查询用到的是一个next数组，next[now][buf[i]]就是指在当前匹配是now的情况下，下一个字符是buf[i]的最佳匹配。

HDU 2222

#include <iostream>
#include <queue>
#include <cstring>
#include <string>
#include <cstdio>
using namespace std;
int n;
const int N = 10010;
class AC_auto
{
    public:
        int next[N*52][26],fail[N*52],end[N*52];
        int root,L;

        int newnode()
        {
            for (int i = 0; i < 26; i++)
            {
                next[L][i] = -1;
            }
            end[L++] = 0;
            return L-1;
        }
        void init()
        {
            L = 0;
            root = newnode();
        }
        
       void insert(char buf[])
       {
            int now = root;
            int len = strlen(buf);
            for (int i = 0 ; i < len; i++)
            {
                int w = buf[i]-'a';
                if (next[now][w] == -1)
                {
                    next[now][w] = newnode();
                }
                now = next[now][w];
            }
            end[now] += 1;
       } 
        
        void build()
        {
            queue<int> Q;
            fail[root] = root;
            for (int i =0; i < 26; i++)
            {
                if (next[root][i] == -1)
                    next[root][i] = root;
                else 
                {
                    fail[next[root][i]] = root;
                    Q.push(next[root][i]);
                }
            }

            while (!Q.empty())
            {
                int now = Q.front();
                Q.pop();
                for(int i = 0; i < 26; i++)
                {
                    if (next[now][i] == -1)
                    {
                        next[now][i] = next[fail[now]][i];
                    }
                    else
                    {
                        fail[next[now][i]] = next[fail[now]][i];
                        Q.push(next[now][i]);
                    }
                }
            }

        }


        int query(char buf[])
        {
            int ans = 0;
            int now = root;
            int len = strlen(buf);
            for(int i = 0; i < len; i++)
            {
                int w = buf[i] - 'a';
                now = next[now][w];
                int temp = now;
                while (temp != root)
                {
                    ans += end[temp];
                    end[temp] = 0;
                    temp = fail[temp];
                }
            }
            return ans;
        }
};
AC_auto a;

void solve()
{
    int m;
    scanf("%d",&m);
    a.init();
    char buf[100];
    char target[1001000];
    for (int i = 0; i < m; i++)
    {
       scanf("%s",buf);
      a.insert(buf); 
    }
    a.build();
    scanf("%s",target);
    printf("%d\n",a.query(target));
}
int main()
{
    scanf("%d",&n);
    for (int i = 0; i < n; i++)
    {
        solve();
    }
    return 0;
}

HDU 2896 

#include <iostream>
#include <queue>
#include <cstring>
#include <vector>
#include <algorithm>
#include <cstdio>
using namespace std;
const int N = 100000;
class AC_auto
{
    public:
        int next[N*10][128],end[N*52],fail[N*52];
        int root,L;
        int newnode()
        {
            for (int i = 0; i < 128; i++)
            {
                next[L][i] = -1;
            }
            end[L++] = 0;
            return L -1;
        }
        void init()
        {
            L = 0;
            root = newnode();
        }
    
        void insert(char buf[],int k)
        {
            int len = strlen(buf);
            int now = root;
            for (int i = 0 ; i < len; i++)
            {
                int w = buf[i];
                if (next[now][w] == -1)
                {
                    next[now][w] = newnode();
                }
                now = next[now][w];
            }
            end[now] = k; 
        }
        void build()
        {
            queue<int> Q;
            fail[root] = root;
            for (int i = 0; i < 128; i++)
            {
                if (next[root][i] == -1)
                    next[root][i] = root;
                else
                {
                    fail[next[root][i]] = root;
                    Q.push(next[root][i]);
                }
            }
            while (!Q.empty())
            {
                int now = Q.front();
                Q.pop();
                for(int i = 0; i < 128; i++)
                {
                    if (next[now][i] == -1)
                    {
                        next[now][i] = next[fail[now]][i];
                    }else
                    {
                        fail[next[now][i]] = next[fail[now]][i];
                        Q.push(next[now][i]);
                    }
                }
            
            }
        }

        vector<int> *query(char buf[],vector<int>* a)
        {
            a->clear();
            int now = root;
            int len = strlen(buf);
            for (int i = 0; i < len; i++)
            {
                int w = buf[i];
                now = next[now][w];
                int temp = now;
                while(temp != root)
                {
                    if (end[temp] != 0)
                    {
                        a->push_back(end[temp]);
                    }
                    temp = fail[temp];
                }
            }
            return a;
        }
};

AC_auto ac;
int n;
int m;

void init()
{
    scanf("%d",&n);
    ac.init();
    char buf[300];
    for (int i = 0; i < n; i++)
    {
        scanf("%s",buf);
        ac.insert(buf,i+1);
    }
    ac.build();
}

void solve()
{
    scanf("%d",&m);
    char buf[11000];
    vector<int> a;
    int sum = 0;
    for (int i = 1; i <= m ;i++)
    {
        scanf("%s",buf);
        ac.query(buf,&a); 
        sort(a.begin(),a.end());
        if (a.size() == 0)
            continue;
        printf("web %d:",i);
        sum++;
        for (int j = 0; j < a.size(); j++)
        {
            if (j == 0 || a[j] != a[j-1])
            {
                printf(" %d",a[j]);
            }
        }
        printf("\n");
    }
    printf("total: %d\n",sum);
}
int main()
{
    init();
    solve();
    return 0;
}

HDU 3065 

#include <iostream>
#include <memory.h>
#include <queue>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 60000;

class AC_auto
{
    public:
        int next[N][26],end[N],d[N],fail[N];
        int root,L;
        int newnode()
        {
            for(int i = 0; i< 26; i++)
                next[L][i] = -1;
            end[L] = 0;
            L++;
            return L-1;
        }

        void init()
        {
            L = 0;
            root = newnode();
            memset(d,0,sizeof(d));
        }
            
        void insert(char buf[],int k)
        {
            int now = root;
            int len = strlen(buf);
            for(int i = 0; i < len; i++)
            {
                int w = buf[i]-'A';
                if (next[now][w] == -1)
                {
                    next[now][w] = newnode();
                }
                now = next[now][w];
            }
            end[now] = k;
        }
        void build()
        {
            queue<int> Q;
            fail[root] = root;
            for(int i = 0; i < 26;i++)
            {
                if (next[root][i] == -1)
                    next[root][i] = root;
                else
                {
                    fail[next[root][i]] = root;
                    Q.push(next[root][i]);
                }
            }
            while (!Q.empty())
            {
                int now = Q.front();
                Q.pop();
                for (int i = 0; i < 26; i++)
                {
                    if (next[now][i] == -1)
                    {
                        next[now][i] = next[fail[now]][i];
                    }
                    else
                    {
                        fail[next[now][i]] = next[fail[now]][i]; 
                        Q.push(next[now][i]);
                    }
                }
            }
        }

        void query(char buf[])
        {
            int len = strlen(buf);
            int now = root;
            for(int i = 0; i < len; i++)
            {
                if (buf[i] >= 'A' && buf[i] <= 'Z')
                {
                    int w = buf[i] - 'A';
                    now = next[now][w];
                }else 
                    now = root;
                int temp = now;
                while (temp != root)
                {
                    if (end[temp])
                    {
                        d[end[temp]]++;
                    }                   
                    temp = fail[temp];
                }

            }
        }
};
vector<string> s;
int n;
AC_auto ac;
char buf[2100000];
void init()
{
    char buf[100];
    ac.init();
    s.clear();
    for (int i = 0; i < n; i++)
    {
        scanf("%s",buf);
        ac.insert(buf,i+1);
        s.push_back(string(buf));
    }
    ac.build();
}


void solve()
{
    scanf("%s",buf);
    ac.query(buf);
    for (int i = 0; i < n; i++)
    {
        if (ac.d[i+1])
        {
            printf("%s: %d\n",s[i].c_str(),ac.d[i+1]);
        }
    } 
}

int main()
{
    while (scanf("%d",&n) != EOF){
    init();
    solve();
    }
    return 0;
}


zearom32
关注
专栏目录
36丨AC自动机：如何用多模式串匹配实现敏感词过滤功能？1
08-03
AC自动机是一种高效的多模式串匹配算法，主要应用于文本处理中的敏感词过滤、关键词搜索等功能。它的全称为Aho-Corasick算法，由Aho和Corasick在1975年提出。AC自动机在Trie树的基础上进行了扩展，增加了失败指针，...
AC 自动机
orz
08-25 1387
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 3633
AC 自动机，全称 Aho-Corasick 自动机，是一种用于字符串搜索的算法，由 Alfred V. Aho 和 Margaret J. Corasick 在 1975 年提出。这个算法是为了解决在一个主文本字符串中查找多个模式字符串（或称为“关键词”）的问题，它可以在线性时间内完成搜索，非常高效。在计算机科学中，Aho-Corasick 算法是 Alfred V. Aho 和 Margaret J. Corasick 于 1975 年发明的一种字符串搜索算法。
ac自动机
weixin_42593130的博客
01-03 249
AC自动机(英语：Aho-Corasick algorithm)是一种用于在文本串中快速搜索多个模式串的算法。它的名字来源于其发明者Alfred V. Aho和Margaret J. Corasick。AC自动机是一种多模式匹配算法，通常被用于在大型文本串或网络流中搜索多个模式串。它的时间复杂度是O(n+m+z)，其中n是文本串的长度，m是模式串的总长度，z是匹配次数。AC自动机在许多文本编辑器和...
数据结构与算法笔记：基础篇 -AC自动机：如何用多模式串匹配实现敏感词过滤功能？
chenjian723122704的专栏
06-18 739
很多支持用户发表文本内容的网站，比如 BBS，大都会有敏感词过滤功能，用来过滤掉用户输入的一些淫秽、反动、谩骂等内容。你有没有想过，这个功能是怎么实现的呢？实际上，这些功能最基本的原理就是字符串匹配算法，也就是通过维护一个敏感词字典，当用户输入一段文字内容之后，通过字符串匹配算法，来查找用户输入的这段文字，是否包含敏感词。如果有，就用 “***” 把它替换掉。我们讲过讲过好几种字符串匹配算法了，它们都可以处理这个问题。但是，对于访问量巨大的网站来说，比如淘宝，用户每天的评论数有几亿、甚至十几亿。
AC自动机算法
懒猫的脚印
08-15 1333
ac自动机，双数组
ac自动机详解
dajiangyou123456的博客
01-27 345
转自大佬的blog：https://www.cnblogs.com/cmmdc/p/7337611.html 简介： 首先简要介绍一下AC自动机：Aho-Corasick automation，该算法在1975年产生于贝尔实验室，是著名的多模匹配算法之一。一个常见的例子就是给出n个单词，再给出一段包含m个字符的文章，让你找出有多少个单词在文章里出现过。要搞懂AC自动机，先得有模式树（字典树）Tri...
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 安装...
数据分析高级培训：客户体验分析-课件
11-10
课程目标： 本课程旨在让学员了解什么是客户体验，客户服务体验的重要性以及常见指标，掌握客户体验的分析方法，学会客户问题的识别以及针对问题制定有效的解决方案。 课程大纲： 客户体验的概述 客户体验的分析方法 客户问题解决的方法论
【微电网潮流】分布式电源微电网潮流【Matlab仿真 7357期】.zip
11-10
CSDN Matlab武动乾坤上传的资料均有对应的代码，代码均可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博客文章底部QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
Unity3d-lesson_EVAC-CITY.zip
11-10
Unity3d实例工程，供学习参考
2023-04-06-项目笔记 - 第三百一十三阶段 - 4.4.2.311全局变量的作用域-311 -2025.11.10
最新发布
11-10
2023-04-06-项目笔记-第三百一十三阶段-课前小分享_小分享1.坚持提交gitee 小分享2.作业中提交代码 小分享3.写代码注意代码风格 4.3.1变量的使用 4.4变量的作用域与生命周期 4.4.1局部变量的作用域 4.4.2全局变量的作用域 4.4.2.1全局变量的作用域_1 4.4.2.311局变量的作用域_311- 2024-11-10
【电机控制】基于matlab PID控制器BLDC电机控制【Matlab仿真 7412期】.zip
11-10
CSDN Matlab武动乾坤上传的资料均有对应的代码，代码均可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博客文章底部QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
【误码率仿真】基于matlab阿拉姆提空间时间块编码STBC（含误码率）【Matlab仿真 7425期】.zip
11-10
CSDN Matlab武动乾坤上传的资料均有对应的代码，代码均可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博客文章底部QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
在线考试-java-基于springBoot的在线考试系统设计与实现
11-10
在线考试-java-基于springBoot的在线考试系统设计与实现
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、付费专栏及课程。

余额充值