AC自动机

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

AC自动机

AC自动机是KMP和Trie的结合，主要处理多模板串匹配问题。下面推荐一个博客，有助于学习AC自动机。

这里还有一个Kuangbin开的 比赛，大家也可以做一下，加深对算法的理解。

下面是比赛中的题目，采用了notonlysuccess的模板。
HDU 2222 Keywords Search
题意：最裸的模板题，给定一些模板串以及一个文本串，要在文本串中找有多少个模板串。 

/*
ID: wuqi9395@126.com
PROG:
LANG: C++
*/
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<cmath>
#include<cstdio>
#include<vector>
#include<string>
#include<fstream>
#include<cstring>
#include<ctype.h>
#include<iostream>
#include<algorithm>
#define INF (1<<30)
#define PI acos(-1.0)
#define mem(a, b) memset(a, b, sizeof(a))
#define rep(i, n) for (int i = 0; i < n; i++)
#define debug puts("===============")
typedef long long ll;
using namespace std;
const int maxnode = 500100;
const int charset = 26;
struct ACAutomaton {
    int ch[maxnode][charset];
    int fail[maxnode];
    int Q[maxnode];
    int val[maxnode];
    int sz;
    int ID[128];

    //初始化,计算字母对应的儿子ID,如:'a'->0 ... 'z'->25
    void init() {
        fail[0] = 0;
        for (int i = 0; i < charset; i++) ID[i + 'a'] = i;
    }
    //重新建树需先Reset
    void reset() {
        memset(ch[0], 0, sizeof(ch[0]));
        sz = 1;
    }
    //将权值为key的字符串a插入到trie中
    void Insert(char *s, int key) {
        int u = 0;
        for ( ; *s; s++) {
            int c = ID[*s];
            if (!ch[u][c]) {
                memset(ch[sz], 0, sizeof(ch[sz]));
                val[sz] = 0;
                ch[u][c] = sz++;
            }
            u = ch[u][c];
        }
        val[u] += key;
    }
    //建立AC自动机,确定每个节点的权值以及状态转移
    void Construct () {
        int *s = Q, *e = Q;
        for (int i = 0; i < charset; i++) {
            if (ch[0][i]) {
                fail[ch[0][i]] = 0;
                *e ++ = ch[0][i];
            }
        }
        while(s != e) {
            int u = *s++;
            for (int i = 0; i < charset; i++) {
                int &v = ch[u][i];
                if (ch[u][i]) {
                    *e ++ = v;
                    fail[v] = ch[fail[u]][i];
                } else {
                    v = ch[fail[u]][i];
                }
            }
        }
    }
    //最基础的查询，询问一个字符串中出现了多少模板串
    int query(char *s) {
        int ans = 0, u = 0;
        for ( ; *s; s++) {
            int c = ID[*s];
            u = ch[u][c];
            int tmp = u;
            while(tmp) {
                ans += val[tmp];
                val[tmp] = 0;
                tmp = fail[tmp];
            }
        }
        return ans;
    }
}AC;
char str[1000100];
int main() {
    AC.init();
    int t, n;
    scanf("%d", &t);
    while(t--) {
        scanf("%d", &n);
        AC.reset();
        for (int i = 0; i < n; i++) {
            scanf("%s", str);
            AC.Insert(str, 1);
        }
        AC.Construct();
        scanf("%s", str);
        printf("%d\n", AC.query(str));
    }
    return 0;
}

HDU 2896 病毒侵袭
题意：有N个病毒，M个文本串，问每个文本串出现了多少个病毒，分别是哪些？一共有多少个文本串出现了病毒？
思路：这道题的病毒可以包含所有可见ASC码值 

/*
ID: wuqi9395@126.com
PROG:
LANG: C++
*/
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<cmath>
#include<cstdio>
#include<vector>
#include<string>
#include<fstream>
#include<cstring>
#include<ctype.h>
#include<iostream>
#include<algorithm>
#define INF (1<<30)
#define PI acos(-1.0)
#define mem(a, b) memset(a, b, sizeof(a))
#define rep(i, n) for (int i = 0; i < n; i++)
#define debug puts("===============")
typedef long long ll;
using namespace std;
const int maxnode = 100100;
const int charset = 128;
struct ACAutomaton {
    int ch[maxnode][charset];
    int fail[maxnode];
    int Q[maxnode];
    int val[maxnode];
    int sz;
    int ID[128];
    void init() {
        fail[0] = 0;
        for (int i = 0; i < charset; i++) ID[i] = i;
    }
    void reset() {
        sz = 1;
        memset(ch[0], 0, sizeof(ch[0]));
    }
    void Insert(char *s, int key) {
        int u = 0;
        for ( ; *s; s++) {
            int c = ID[*s];
            if (!ch[u][c]) {
                memset(ch[sz], 0, sizeof(ch[sz]));
                val[sz] = 0;
                ch[u][c] = sz++;
            }
            u = ch[u][c];
        }
        val[u] = key;
    }
    void Construct () {
        int *s = Q, *e = Q;
        for (int i = 0; i < charset; i++) {
            if (ch[0][i]) {
                *e++ = ch[0][i];
                fail[ch[0][i]] = 0;
            }
        }
        while(s != e) {
            int u = *s++;
            for (int i = 0; i < charset; i++) {
                int &v = ch[u][i];
                if (v) {
                    *e++ = v;
                    fail[v] = ch[fail[u]][i];
                } else {
                    v = ch[fail[u]][i];
                }
            }
        }
    }
    void query(char *s, int &tot, int id) {
        int ans = 0, u = 0;
        set<int> S;
        set<int>::iterator it;
        S.clear();
        for (; *s; s++) {
            int c = ID[*s];
            u = ch[u][c];
            int tmp = u;
            while(tmp) {
                if (val[tmp]) S.insert(val[tmp]), ans++;
                tmp = fail[tmp];
            }
        }
        if (ans) {
            printf("web %d:", id);
            for (it = S.begin(); it != S.end(); it++) printf(" %d", *it);
            putchar('\n');
            tot++;
        }
    }
}AC;
char buf[210], str[10100];
int main () {
    int n, m, tot = 0;
    scanf("%d", &n);
    AC.init();
    AC.reset();
    for (int i = 0; i < n; i++) {
        scanf("%s", buf);
        AC.Insert(buf, i + 1);
    }
    AC.Construct();
    scanf("%d", &m);
    for (int i = 0; i < m; i++) {
        scanf("%s", str);
        AC.query(str, tot, i + 1);
    }
    printf("total: %d\n", tot);
    return 0;
}

HDU 3065 病毒侵袭持续中
题意：有N个病毒，一个文本串，问文本串中每个病毒出现了多少次
思路：也是基础的模板，是多case。。 

/*
ID: wuqi9395@126.com
PROG:
LANG: C++
*/
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<cmath>
#include<cstdio>
#include<vector>
#include<string>
#include<fstream>
#include<cstring>
#include<ctype.h>
#include<iostream>
#include<algorithm>
#define INF (1<<30)
#define PI acos(-1.0)
#define mem(a, b) memset(a, b, sizeof(a))
#define rep(i, n) for (int i = 0; i < n; i++)
#define debug puts("===============")
typedef long long ll;
using namespace std;
const int maxnode = 50010;
const int charset = 128;
int cnt[1100];
struct ACAutomaton {
    int ch[maxnode][charset];
    int fail[maxnode];
    int Q[maxnode];
    int val[maxnode];
    int sz;
    int ID[128];
    void init() {
        fail[0] = 0;
        for (int i = 0; i < charset; i++) ID[i] = i;
    }
    void reset() {
        sz = 1;
        memset(ch[0], 0, sizeof(ch[0]));
    }
    void Insert(char *s, int key) {
        int u = 0;
        for ( ; *s; s++) {
            int c = ID[*s];
            if (!ch[u][c]) {
                memset(ch[sz], 0, sizeof(ch[sz]));
                val[sz] = 0;
                ch[u][c] = sz++;
            }
            u = ch[u][c];
        }
        val[u] = key;
    }
    void Construct () {
        int *s = Q, *e = Q;
        for (int i = 0; i < charset; i++) {
            if (ch[0][i]) {
                *e++ = ch[0][i];
                fail[ch[0][i]] = 0;
            }
        }
        while(s != e) {
            int u = *s++;
            for (int i = 0; i < charset; i++) {
                int &v = ch[u][i];
                if (v) {
                    *e++ = v;
                    fail[v] = ch[fail[u]][i];
                } else {
                    v = ch[fail[u]][i];
                }
            }
        }
    }
    void query(char *s) {
        int u = 0;
        for (; *s; s++) {
            int c = ID[*s];
            u = ch[u][c];
            int tmp = u;
            while(tmp) {
                if (val[tmp]) cnt[val[tmp]]++;
                tmp = fail[tmp];
            }
        }
    }
} AC;
char buf[1100][55], str[2000100];
int main () {
    int n, m, tot = 0;
    AC.init();
    while(~scanf("%d", &n)) {
        AC.reset();
        for (int i = 0; i < n; i++) {
            scanf("%s", buf[i]);
            AC.Insert(buf[i], i + 1);
            cnt[i + 1] = 0;
        }
        AC.Construct();
        scanf("%s", str);
        AC.query(str);
        for (int i = 1; i <= n; i++) if (cnt[i]) printf("%s: %d\n", buf[i - 1], cnt[i]);
    }
    return 0;
}

ZOJ 3430 Detect the Virus
题意：有一种编码方式，将输进来的字符转化为二进制，然后6个为一组，不足补零，得到一个新的数字，每个数字对应一个字符（见题面）。现在给你已经编码过的n个病毒，和m个编码过的文本串，问每个文本串各包含多少种病毒。
思路：这里反编码的时候，会发现可能有256种状态，所以不能用字符串表示。反编码之后就是裸的AC自动机。 
/*
ID: wuqi9395@126.com
PROG:
LANG: C++
*/
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<cmath>
#include<cstdio>
#include<vector>
#include<string>
#include<fstream>
#include<cstring>
#include<ctype.h>
#include<iostream>
#include<algorithm>
#define INF (1<<30)
#define PI acos(-1.0)
#define mem(a, b) memset(a, b, sizeof(a))
#define rep(i, n) for (int i = 0; i < n; i++)
#define debug puts("===============")
typedef long long ll;
using namespace std;
const int maxnode = 510 * 64;
const int charset = 256;
struct ACAutomaton {
    int ch[maxnode][charset];
    int fail[maxnode];
    int Q[maxnode];
    int val[maxnode];
    int sz;
    int ID[256];
    void init() {
        fail[0] = 0;
        //for (int i = 0; i < charset; i++) ID[i] = i;
    }
    void reset() {
        sz = 1;
        memset(ch[0], 0, sizeof(ch[0]));
    }
    void Insert(unsigned char s[], int key, int len) {
        int u = 0;
        for (int i = 0; i < len; i++) {
            int c = s[i];
            if (!ch[u][c]) {
                memset(ch[sz], 0, sizeof(ch[sz]));
                val[sz] = 0;
                ch[u][c] = sz++;
            }
            u = ch[u][c];
        }
        val[u] = key;
    }
    void Construct () {
        int *s = Q, *e = Q;
        for (int i = 0; i < charset; i++) {
            if (ch[0][i]) {
                *e++ = ch[0][i];
                fail[ch[0][i]] = 0;
            }
        }
        while(s != e) {
            int u = *s++;
            for (int i = 0; i < charset; i++) {
                int &v = ch[u][i];
                if (v) {
                    *e++ = v;
                    fail[v] = ch[fail[u]][i];
                } else {
                    v = ch[fail[u]][i];
                }
            }
        }
    }
    void query(unsigned char s[], int len) {
        int u = 0, ans = 0;
        bool vis[520] = {0};
        for (int i = 0; i < len; i++) {
            int c = s[i];
            u = ch[u][c];
            int tmp = u;
            while(tmp) {
                if (val[tmp] && !vis[val[tmp]]) {
                    ans++, vis[val[tmp]] = 1;
                }
                tmp = fail[tmp];
            }
        }
        printf("%d\n", ans);
    }
} AC;
char s[4000];
unsigned char g[4000];
unsigned char now[4000];
void get(char *s, int len) {
    for (int i = 0; i < len; i++) {
        if (s[i] >= 'A' && s[i] <= 'Z') g[i] = s[i] - 'A';
        else if (s[i] >= 'a' && s[i] <= 'z') g[i] = s[i] - 'a' + 26;
        else if (s[i] >= '0' && s[i] <= '9') g[i] = s[i] - '0' + 52;
        else if (s[i] == '+') g[i] = 62;
        else g[i] = 63;
    }
    g[len] = 0;
}
int change(unsigned char g[], int len) {
    int cnt = 0;
    for (int i = 0; i < len; i += 4) {
        now[cnt++] = (g[i] << 2) | (g[i + 1] >> 4);
        if (i + 2 < len) now[cnt++] = (g[i + 1] << 4) | (g[i + 2] >> 2);
        if (i + 3 < len) now[cnt++] = (g[i + 2] << 6) | g[i + 3];
    }
    return cnt;
}
int main () {
    int n, m;
    AC.init();
    while(~scanf("%d", &n)) {
        AC.reset();
        for (int i = 0; i < n; i++) {
            scanf("%s", s);
            int len = strlen(s);
            while(s[len - 1] == '=') len--;
            get(s, len);
            int cnt = change(g, len);
            AC.Insert(now, i + 1, cnt);
        }
        AC.Construct();
        scanf("%d", &m);
        while(m--) {
            scanf("%s", s);
            int len = strlen(s);
            while(s[len - 1] == '=') len--;
            get(s, len);
            int cnt = change(g, len);
            AC.query(now, cnt);
        }
        putchar('\n');
    }
    return 0;
}

POJ 2778 DNA Sequence
题意：DNA的序列由ACTG四个字母组成，现在给定m个不可行的序列。问随机构成的长度为n的序列中，有多少种序列是可行的（只要包含一个不可行序列便不可行）。个数很大，对100000取模。 
思路：AC自动机 + DP  解题报告

HDU 2243 考研路茫茫――单词情结
题意：给定一些词根，如果一个单词包含有词根，则认为是有效的。现在问长度不超过L的单词里面，有多少有效的单词？

ZOJ 2619 Generator
题意：给定一个数N，代表可以选前N个字母。然后给定一个仅有前N个字母组成的字符串，问从空串开始构造，每次可以在已有基础上从前N个字母中挑选一个加在后面，问构造的字符串的长度期望是多少？


持续更新中

SIO__Five
关注
专栏目录
36丨AC自动机：如何用多模式串匹配实现敏感词过滤功能？1
08-03
AC自动机是一种高效的多模式串匹配算法，主要应用于文本处理中的敏感词过滤、关键词搜索等功能。它的全称为Aho-Corasick算法，由Aho和Corasick在1975年提出。AC自动机在Trie树的基础上进行了扩展，增加了失败指针，...
AC 自动机
orz
08-25 1377
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 3490
AC 自动机，全称 Aho-Corasick 自动机，是一种用于字符串搜索的算法，由 Alfred V. Aho 和 Margaret J. Corasick 在 1975 年提出。这个算法是为了解决在一个主文本字符串中查找多个模式字符串（或称为“关键词”）的问题，它可以在线性时间内完成搜索，非常高效。在计算机科学中，Aho-Corasick 算法是 Alfred V. Aho 和 Margaret J. Corasick 于 1975 年发明的一种字符串搜索算法。
ac自动机
weixin_42593130的博客
01-03 247
AC自动机(英语：Aho-Corasick algorithm)是一种用于在文本串中快速搜索多个模式串的算法。它的名字来源于其发明者Alfred V. Aho和Margaret J. Corasick。AC自动机是一种多模式匹配算法，通常被用于在大型文本串或网络流中搜索多个模式串。它的时间复杂度是O(n+m+z)，其中n是文本串的长度，m是模式串的总长度，z是匹配次数。AC自动机在许多文本编辑器和...
数据结构与算法笔记：基础篇 -AC自动机：如何用多模式串匹配实现敏感词过滤功能？
最新发布
chenjian723122704的专栏
06-18 734
很多支持用户发表文本内容的网站，比如 BBS，大都会有敏感词过滤功能，用来过滤掉用户输入的一些淫秽、反动、谩骂等内容。你有没有想过，这个功能是怎么实现的呢？实际上，这些功能最基本的原理就是字符串匹配算法，也就是通过维护一个敏感词字典，当用户输入一段文字内容之后，通过字符串匹配算法，来查找用户输入的这段文字，是否包含敏感词。如果有，就用 “***” 把它替换掉。我们讲过讲过好几种字符串匹配算法了，它们都可以处理这个问题。但是，对于访问量巨大的网站来说，比如淘宝，用户每天的评论数有几亿、甚至十几亿。
AC自动机算法
懒猫的脚印
08-15 1330
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 安装...
HDU 2243 考研路茫茫――单词情结 (AC自动机 + dp）
SIOFive的专栏
08-20 1344
HDU 2243 考研路茫茫――单词情结 题意：给定一些词根，如果一个单词包含有词根，则认为是有效的。现在问长度不超过L的单词里面，有多少有效的单词？ 思路：这道题和POJ 2778 是同样的思路。POJ 2778是要找出长度为L的单词里面有多少无效的单词。那么根据同样的方法构造矩阵，然后所有无效的单词个数为 A + A^2 + ... + A^l 个。而所有单词的个数为26 + 26
POJ 2778 DNA Sequence (AC自动机 + dp)
SIOFive的专栏
08-20 1210
DNA Sequence 题意：DNA的序列由ACTG四个字母组成，现在给定m个不可行的序列。问随机构成的长度为n的序列中，有多少种序列是可行的（只要包含一个不可行序列便不可行）。个数很大，对100000取模。 思路：推荐一个博客，讲的非常清楚。 这种题目，n很大，首先想到的就是用矩阵来优化。那么如何构造转移方程呢：首先建立一棵Trie，然后按照AC自动机的方式构造fail指针，然后
UVA 11732 strcmp() Anyone? (Trie)
SIOFive的专栏
08-13 1207
strcmp() Anyone? 题意：输入n个字符串，两两调用一次strcmp()，问字符比较的总次数是多少？ 考虑strcmp()的实现如下： int strcmp (char *s, char * t) { int i; for (i = 0; s[i] == t[i]; i++) if (s[i] == '\0') return 0; return s[i] - t[
HDU 4821 String
SIOFive的专栏
07-23 957
String 题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4821 题目大意： 给定一个字符串（最长10^5）。从中选一个长度为 m * l 的子串，要求该子串能拆分为m个长度为 l 的一一不同的串。问有多少种取法。 解题思路： 比赛的时候，没有将串按照模 l 之后分类，导致TLE。。 字符串的哈希为：a[i
LA 3942 Remember the Word (Trie)
SIOFive的专栏
08-12 916
Remember the Word 题目：链接 题意：给出一个有S个不同单词组成的字典和一个长字符串。把这个字符串分解成若干个单词的连接（单词可以重复使用），有多少种方法？ 思路：令d[i]表示从字符i开始的字符串（后缀s[i..L]）的分解数，这d[i] = sum{d(i+len(x)) | 单词x是其前缀}。然后将所有单词建成一个Trie树，就可以将搜索单词的复杂度降低
字符串总结
SIOFive的专栏
08-15 802
字符串总结
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、付费专栏及课程。

余额充值