AC 自动机

最新推荐文章于 2024-02-22 00:23:59 发布
最新推荐文章于 2024-02-22 00:23:59 发布
阅读量296 收藏
点赞数
分类专栏： 字符串算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/czysjr/article/details/41487817
版权

ac自动机 也不知道 学过多少遍了。

它具体干的事情就是在一棵trie树上跑kmp。

我们先来想一想普通的kmp在做些什么：

fail数组建立时：

维护一个j值， 表示当前点的上一个节点最多可以匹配到匹配串的哪里， 然后一直往前推j (令j = next[j]) , 直到j + 1 == 当前点。

匹配时也差不多。

在trie树上fail指针想要实现的内容是和kmp一样的， 但是考虑到它们在结构上的一定 区别和共性

在一个子串中， fail[i] 与 i 的关系是: fail[i] 的位置一定在 i 的前面

而在trie树上， fail[i] 与 i 的关系是 ： fail[i] 的深度 一定小于 i。

好了其它的地方就都一样了。

所以唯一不一样的地方就是要保证访问的顺序， 这可以用bfs 简单实现。

这时候ac自动机就基本等同于kmp了。


在代码实现上有一个小技巧， 就是因为ac自动机 表示子串时大多用应用了指针思想的trie树， 所以每一次找第一个 j + 1 == i 的那个j 时并不用真的像kmp那样while上去， 而是可以直接在一个 节点p 没有q这个后继时 将p 的q 后继指向 fail[p]的 q 后继。 考虑到 fail[p] 的深度比 p 小（即它的后继已经如此处理过了）， 所以 p 这时指向的就是其 所有fail 上去的节点中 拥有 q 后继的深度最大的。


代码写起来非常简单优美， 只有60多行， 感人肺腑。


上两道裸题：

hdu 2222

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <queue>
#define MAXN 510005
using namespace std;
char s[MAXN * 2];
int root, cnt, next[MAXN][26], fail[MAXN], end[MAXN];
int newnode(){
	for(int i = 0; i < 26; i ++)next[cnt][i] = -1;
	end[cnt ++] = 0;
	return cnt - 1;
}
void insert(char s[]){
	int len = strlen(s), now = root;
	for(int i = 0; i < len; i ++){
		if(next[now][s[i] - 'a'] == -1)next[now][s[i] - 'a'] = newnode();
		now = next[now][s[i] - 'a'];
	}end[now] ++;
}
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 s[]){
	int len = strlen(s), now = root, res = 0;
	for(int i = 0; i < len; i ++){
		now = next[now][s[i] - 'a'];
		int t = now;
		while(t != root){
			res += end[t];
			end[t] = 0;
			t = fail[t];
		}
	}return res;
}
int main(){
	int t; scanf("%d", &t); while(t --){
		cnt = 0; root = newnode();
		int n; scanf("%d", &n);while(n --){
			scanf("%s", s);insert(s);
		}
		build();
		scanf("%s", s);
		printf("%d\n", query(s));
	}	
	return 0;
}


hdu 2896

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <queue>
#define MAXN 100005
using namespace std;
int n, m, root, cnt, next[MAXN][128], fail[MAXN], end[MAXN], summ, ans[5];
bool exist[508];
char s[10005];
int newnode(){
	for(int i = 0; i < 128; i ++)next[cnt][i] = -1;
	end[cnt ++] = -1; return cnt - 1;
}
void insert(char s[], int ind){
	int now = root, len = strlen(s);
	for(int i = 0; i < len; i ++){
		if(next[now][s[i]] == -1)next[now][s[i]] = newnode();
		now = next[now][s[i]];	
	} end[now] = ind;
}
void makefail(){
	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 u = q.front(); q.pop();
		for(int i = 0; i < 128; i ++)
			if(next[u][i] == -1)next[u][i] = next[fail[u]][i];
			else fail[next[u][i]] = next[fail[u]][i], q.push(next[u][i]);
	}
}
void query(char s[]){
	int now = root, len = strlen(s);
	memset(exist, 0, sizeof(exist));
	for(int i = 0; i < len; i ++){
		now = next[now][s[i]];
		int t = now;
		while(t != root){
			if(end[t] != -1 && !exist[end[t]])ans[++ ans[0]] = end[t], exist[end[t]] = 1;
			t = fail[t];
		}
	}
}
int main(){
	scanf("%d", &n);
	root = newnode();
	for(int i = 1; i <= n; i ++)scanf("%s", s), insert(s, i);
	makefail();
	scanf("%d", &m);
	for(int i = 1; i <= m; i ++){
		scanf("%s", s); ans[0] = 0;
		query(s);
		if(ans[0]){
			printf("web %d:", i);
			sort(ans + 1, ans + ans[0] + 1);
			for(int i = 1; i <= ans[0]; i ++)printf(" %d", ans[i]);puts("");
			summ ++;
		}
	}printf("total: %d\n", summ);
	return 0;
}


hdu 3065 同裸题， 练手

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <queue>
#define MAXL 2000005
#define MAXN 250005
using namespace std;
int root, n, next[MAXN][26], fail[MAXN], cnt, end[MAXN][20], ans[1005];
char s[MAXL], ch[1005][50];
queue<int>q;
int newnode(){
	memset(next[cnt], -1, sizeof(next[cnt]));
	end[cnt][0] = 0; cnt ++;
	return cnt - 1;
}
void insert(char s[], int ind){
	int len = strlen(s), now = root;
	for(int i = 0; i < len; i ++){
		if(next[now][s[i] - 'A'] == -1)next[now][s[i] - 'A'] = newnode();
		now = next[now][s[i] - 'A'];
	}end[now][++ end[now][0]] = ind;
}
void build(){
	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 u = q.front(); q.pop();
		for(int i = 0; i < 26; i ++)
			if(next[u][i] == -1)next[u][i] = next[fail[u]][i];
			else fail[next[u][i]] = next[fail[u]][i], q.push(next[u][i]);
	}
}
void query(char s[]){
	int len = strlen(s), now = root;
	for(int i = 0; i < len; i ++){
		if(s[i] < 'A' || s[i] > 'Z'){now = root; continue;}
		now = next[now][s[i] - 'A'];
		int t = now;
		while(t != root){
			if(end[t][0]){
				for(int j = 1; j <= end[t][0]; j ++)ans[end[t][j]] ++;
			}
			t = fail[t];
		}
	}
}
int main(){
	while(scanf("%d", &n) != EOF){
	cnt = 0;
	root = newnode();
	memset(ans, 0, sizeof(ans));
	scanf("%d", &n);for(int i = 1; i <= n; i ++){
		scanf("%s", ch[i]);
		insert(ch[i], i);
	}
	build();
	scanf("%s", s);
	query(s);
	for(int i = 1; i <= n; i ++)
		if(ans[i]){
			printf("%s: %d\n", ch[i], ans[i]);
		}
	}
	return 0;
}


【ac 自动机上的dp】

ac 自动机 有一个较为灵活的end数组， 在前面出现的练习里， 它有着一些很显然的应用： 记录是否为结束字符， 记录是哪个子串的结束字符等， 但是它可以有一些更好的应用。 比如说 可以把end记录为： 当前这个点的所有后缀是不是有一个是一个字符串的结束字符。 这个显然把 所有它的 fail 指针记录的end 或起来就可以了， 但是可以有一些很好的用途。

如：

bzoj 1030

长 m 的所有字符串中有多少个是包含 任意一个子串的。

考虑不包含的情况， 如果经过了任意一个结束字符它以及它的所有儿子不包含的情况就是0了。

考虑 长为 i 的串， 当前在 点j ， 有 f[i][j] 中情况不包含子串， 对于 a ~ z 每一个下一步的可能 k, f[i + 1][next[j][k]都可以加上 f[i][j] 当然前提是j 这个点 没有是结束字符的后缀。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <queue>
#define MAXN 10005
#define mod 10007
using namespace std;
int n, m, cnt, next[MAXN][26], root, end[MAXN], fail[MAXN], f[110][MAXN];
char s[MAXN];
inline int newnode(){
    memset(next[cnt], -1, sizeof(next[cnt]));
    cnt ++ ; return cnt - 1;
}
void insert(char s[]){
    int len = strlen(s), p = root;
    for(int i = 0; i < len; i ++){
        if(next[p][s[i] - 'A'] == -1)next[p][s[i] - 'A'] = newnode();
        p = next[p][s[i] - 'A'];
    }end[p] = 1;
}
queue<int>q;
void build(){
    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 u = q.front(); q.pop();
        for(int i = 0; i < 26; i ++){
            if(next[u][i] == -1)next[u][i] = next[fail[u]][i];
            else fail[next[u][i]] = next[fail[u]][i], end[next[u][i]] |= end[next[fail[u]][i]], q.push(next[u][i]);
        }
    }
}
int main(){
    root = newnode();
    scanf("%d%d", &n, &m);while(n --){
        scanf("%s", s);insert(s);
    } build();
    f[0][0] = 1;
    for(int i = 0; i < m; i ++)
        for(int j = 0; j < cnt; j ++)if(f[i][j])
            for(int k = 0; k < 26; k ++){
                int now = next[j][k];
                if(!end[now])
                    f[i + 1][now] = (f[i + 1][now] + f[i][j]) % mod;
            }
    int ans = 0;
    for(int i = 0; i < cnt; i ++)ans = (ans + f[m][i]) % mod;
    int total = 1;
    for(int i = 1; i <= m; i ++)total = total * 26 % mod;
    cout<<(total - ans + mod) % mod<<endl;
    return 0;
}

poj 3691

问修改量最少的方法使得 在母串中不存在任何子串。

还是一道记录一下end就行了的简单dp，

转移仍然是 字符串 匹配最经典的转移： 当母串在i， 子串在j时的balabala, 当然这道题的balabala就是母串最少的修改次数了， 很简单很经典。 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <queue>
#define MAXN 5005
using namespace std;
int n, cnt, root, next[MAXN][5], fail[MAXN], f[1005][MAXN];
bool end[MAXN];
char s[1005];
inline int newnode(){
	memset(next[cnt], -1, sizeof(next[cnt]));
	end[cnt ++] = 0; return cnt - 1;
}
inline void insert(char s[]){
	int p = root, len = strlen(s);
	for(int i = 0; i < len; i ++){
		int c;
		if(s[i] == 'A')c = 0;
		if(s[i] == 'C')c = 1;
		if(s[i] == 'G')c = 2;
		if(s[i] == 'T')c = 3;
		if(next[p][c] == -1)next[p][c] = newnode();
		p = next[p][c];
	} end[p] = 1;
}
queue<int>q;
void build(){
	fail[root] = root;
	for(int i = 0; i <= 3; 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 u = q.front(); q.pop();
		for(int i = 0; i <= 3; i ++){
			if(next[u][i] == -1)next[u][i] = next[fail[u]][i];
			else fail[next[u][i]] = next[fail[u]][i], end[next[u][i]] |= end[next[fail[u]][i]], q.push(next[u][i]);
		}
	}
}
int main(){
	int cas = 0;
	while(scanf("%d", &n) && n){
		cnt = 0; root = newnode();
		for(int i = 1; i <= n; i ++)scanf("%s", s), insert(s);
		build();
		scanf("%s", s + 1);
		int len = strlen(s + 1);
		for(int i = 1; i <= len; i ++){
			if(s[i] == 'A')s[i] = 0;
			if(s[i] == 'C')s[i] = 1;
			if(s[i] == 'G')s[i] = 2;
			if(s[i] == 'T')s[i] = 3;
		}
		for(int i = 1; i <= len; i ++)for(int j = 0; j <= cnt; j ++)f[i][j] = MAXN;
		f[0][0] = 0;
		for(int i = 0; i < len; i ++)
			for(int j = 0; j < cnt; j ++)if(f[i][j] != MAXN){
				for(int k = 0; k <= 3; k ++)
					if(!end[next[j][k]])
						f[i + 1][next[j][k]] = min(f[i + 1][next[j][k]], f[i][j] + (k != s[i + 1]));
			}
		int ans = MAXN;
		for(int i = 0; i < cnt; i ++)ans = min(ans, f[len][i]);
		printf("Case %d: ", ++ cas);if(ans == MAXN)puts("-1"); else cout<<ans<<endl;
	}
	return 0;
}

hdu 3341 lost's revenge

也是 很简单的转移， 把四维的数组压成一维 就可以啦， 还没有写呢有时间补上

czysjr
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AC自动机
03-06
**AC自动机（Aho-Corasick算法）**是一种高效的字符串搜索算法，它基于字典树（Trie）数据结构，能够一次性查找多个模式串在文本中的出现情况。AC自动机的主要优势在于避免了对同一个文本位置多次进行模式匹配，大大...
ac自动机.pptx
07-14
要学AC自动机需要自备两个前置技能:KMP和trie树(其实个人感觉不会kmp也行,失配指针的概念并不难) 其中,KMP是用于一对一的字符串匹配,而trie虽然能用于多模式匹配,但是每次匹配失败都需要进行回溯,如果模式串很长的话...
关于 AC 自动机
weixin_43501634的博客
02-22 2129
AC 自动机，全称 Aho-Corasick 自动机，是一种用于字符串搜索的算法，由 Alfred V. Aho 和 Margaret J. Corasick 在 1975 年提出。这个算法是为了解决在一个主文本字符串中查找多个模式字符串（或称为“关键词”）的问题，它可以在线性时间内完成搜索，非常高效。在计算机科学中，Aho-Corasick 算法是 Alfred V. Aho 和 Margaret J. Corasick 于 1975 年发明的一种字符串搜索算法。
ac自动机
weixin_42593130的博客
01-03 222
AC自动机(英语：Aho-Corasick algorithm)是一种用于在文本串中快速搜索多个模式串的算法。它的名字来源于其发明者Alfred V. Aho和Margaret J. Corasick。AC自动机是一种多模式匹配算法，通常被用于在大型文本串或网络流中搜索多个模式串。它的时间复杂度是O(n+m+z)，其中n是文本串的长度，m是模式串的总长度，z是匹配次数。AC自动机在许多文本编辑器和...
AC自动机算法
懒猫的脚印
08-15 1298
ac自动机，双数组
ac自动机详解
dajiangyou123456的博客
01-27 318
转自大佬的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 365
第一步，构建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...
java ac自动机_ac自动机java版
weixin_35952929的博客
02-23 332
【实例简介】从别的共享资源下载的java版ac自动机，已验证使用非常好。【实例截图】【核心代码】ahocorasick_java-1.1└── ahocorasick_java-1.1├── ahocorasick│ ├── pom.xml│ ├── src│ │ └── main│ │ └── java│ │ └── org│ │ ...
AC自动机_AC自动机模板_
09-30
AC自动机，全称为Aho-Corasick自动机，是一种字符串搜索算法，广泛应用于信息学奥林匹克竞赛、数据结构与算法竞赛以及文本处理等领域。它的主要功能是高效地在一个字符串集合中进行多模式匹配，即同时查找多个模式串...
AC自动机模板
12-08
**AC自动机（Aho-Corasick Algorithm）模板** AC自动机是一种字符串搜索算法，它在文本中查找多个模式串的出现情况。该算法由艾伦·科拉斯和戈登·科拉斯在1975年提出，是KMP算法和后缀自动机的结合，具有高效性和...
中文高性能AC自动机代码
11-05
**AC自动机（Aho-Corasick算法）**是一种在字符串搜索中用于高效查找多个模式串的算法。在中文文本处理中，AC自动机尤其适用，因为它能够一次性处理大量关键词，避免了对文本的多次扫描。这个算法由Aho和Corasick在...
pillow_heif-0.17.0-pp39-pypy39_pp73-macosx_14_0_arm64.whl
07-27
基本介绍 名称与起源：Pillow，原名为PIL（Python Imaging Library），但PIL只支持Python 2版本。随着Python 3的普及，Pillow作为PIL的一个分支出现，兼容Python 3并提供更多的功能和改进。 主要功能：Pillow支持多种图像格式的打开、保存、显示以及基本的图像操作和处理，如裁剪、缩放、旋转、翻转、滤镜应用等。 跨平台性：Pillow库可以在不同的操作系统上运行，包括Windows、Linux和MacOS等。 主要功能模块 Pillow库包含多个功能模块，每个模块都提供了特定的图像处理功能。以下是一些常用的模块： Image：用于处理图像文件，提供打开、保存、调整大小、旋转、裁剪、滤镜等功能。 ImageDraw：提供在图像上绘制各种形状（如线条、矩形、圆形）和文本的功能。 ImageFont：用于加载和使用TrueType字体文件，以便在图像上绘制文本时设置字体样式、大小和颜色。 ImageFilter：提供各种滤镜效果，如模糊、锐化、边缘增强等，用于图像增强、特效处理和图像识别等应用。 ImageEnhance：用于调整图像的亮度、对比度、颜色饱和度等参数，使图像更加清晰、明亮或具有特定的调色效果。 高级功能 除了基本的图像处理功能外，Pillow还支持一些高级功能，如色彩空间转换、直方图均衡化等。这些功能可以帮助用户进行更复杂的图像处理和分析。
cykooz.resizer-3.0.0-cp310-cp310-macosx_11_0_arm64.whl
07-27
python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！
[毕设]Delphi题库管理与试卷自动生成系统.zip
07-27
[毕设]Delphi题库管理与试卷自动生成系统
131 种水果、蔬菜和坚果的 90380张的高质量图像数据集+图像识别与定位+该数据集相关的研究论文
07-27
<项目介绍> 包含131 种水果、蔬菜和坚果的 90380张的高质量图像数据集+该数据集相关的研究论文。可供深度学习图像识别与定位。 - 训练集大小：67700 个图像 测试集大小：22888 个图像 文件名格式：image_index_100.jpg（例如 32_100.jpg）或 r_image_index_100.jpg（例如 r_32_100.jpg）或 r2_image_index_100.jpg 或 r3_image_index_100.jpg。 “r”代表旋转水果。 “r2”表示水果绕第三轴旋转。 “100”来自图像尺寸（100x100 像素）。 水果是如何拍摄的: 1:使用 C920 摄像机拍摄水果。最好的网络摄像头之一。 2:在水果后面，我们放了一张白纸作为背景。 3:将水果和蔬菜种植在低速电机（3转/分钟）的轴中，并录制一段20秒的短片。 下载后请首先打开README.md文件（如有），仅供学习参考, 切勿用于商业用途。 --------
Matlab实现斑点鬣狗优化算法SHO-CNN-BiLSTM-Mutilhead-Attention多变量时序预测.rar
07-27
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
[毕设]HTTP服务器开发与设计.zip
最新发布
07-27
[毕设]HTTP服务器开发与设计
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、付费专栏及课程。

余额充值