AC自动机

AC自动机

应用：一个字符串s，多个字符串p
求每个p在s中出现的次数

实现

将每个p塞进字典树中，构造AC自动机，用s进行匹配

朴素算法

1.枚举s中每一对i和j（0<i<=j<s.size()），对每个p进行匹配，计算每一对i和j对答案的贡献

用AC自动机匹配（改进的朴素算法）

AC自动机有两种边，字典树的边和fail指针

fail指针

如图j的fail指针是j1而不是j2
因为从i到j，ab是cab的最长公共后缀，而b不是
fail指针指向的是当前状态的最长公共后缀

用图直观的感受一下匹配过程

eg：
s: cabdc
p: cabd b bdc dc

1.构造完成的AC自动机（展示部分边，蓝色为fail指针，黑色为字典树的边绿色为p中的最后一个字符）

2.开始匹配

首先枚举j，对每一个j进行i的枚举（跳fail指针）
首先j=0，i=0;（此处省略j=0,j=1。。。）

直到j=2，此时


i=0,开始枚举i（跳fail指针），显然i和j的路径上cab不存在于p中

j跳到j1，此时

i和j1的路径上b存在于p中，ans+1;

发现i直接从0跳到了2，而i=1即

不用判断，显然p中不存在ab，
假如存在，则字典树由每一个p构成的

（根据fail指针的定义）j的fail指针便会连接j2并且跳到j2，而不是j1
（而fail指针却连接到j1，则说明不存在ab）

枚举完i后，j++，枚举i；

此时j指向d

cabd存在，ans++,
bd不存在；
d存在，ans++;

枚举完j后，接着j++，j指向c；

观察字典树

j应该跳到此处，此时i从b开始枚举（其实虚线的边在构造AC自动机时，作为字典树的边就已经连上了（构造AC自动机时改变了字典树的结构，增加了一些原来不存在的边，如此虚线的边），所以在匹配的过程中j是直接在字典树上走的）

若j跳到j1的位置，i从d开始枚举

显然第二种会漏掉bdc，而第一种是对的，因为bd是cabd的最长公共后缀，而d不是，可以保证i尽量从靠近0开始枚举
j通过d的fail指针的出边c，找到跳跃的位置

而且i之前的位置不用判断，因为p中不存在cabdc,abdc
因为字典树是由p构成的，若存在abdc
则abd为cabd的最长公共后缀，fail指针会指向另外的位置（而fail指针指向j，则说明不存在abdc）

如果c不存在则j跳至rt，接着j++枚举下一个j；

枚举完i后，j++
一直这样下去直到匹配结束；

如何构造AC自动机

未完待续。。。

代码如下

（洛谷 P3808 【模板】AC自动机（简单版））

#include<iostream>
#include<string.h>
#include<queue>
#include<algorithm>
#include<vector>
#include<iomanip>
#include<map>
#include<string>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = 1e6 + 7;
int tire[maxn][26], fail[maxn], cnt = 0;
int exist[maxn];
void add(string s, int len) {
	int i = -1, now = 0;
	while (i <= len - 2) {
		if (!tire[now][s[++i] - 'a'])tire[now][s[i] - 'a'] = ++cnt;
		now = tire[now][s[i] - 'a'];
	}
	exist[now]++;
}
void build() {
	queue<int> Q;
	for (int i = 0; i < 26; ++i) {
		if (tire[0][i])Q.push(tire[0][i]);
	}
	while (!Q.empty()) {
		int now = Q.front(); Q.pop();
		for (int i = 0; i < 26; ++i) {
			if (tire[now][i]) {
				fail[tire[now][i]] = tire[fail[now]][i]; Q.push(tire[now][i]);
			}
			else tire[now][i] = tire[fail[now]][i];
		}
	}
}
int query(string s, int len) {
	int res = 0, now = 0;
	for (int i = -1; i <= len - 2;) {
		now = tire[now][s[++i] - 'a'];
		for (int j = now; j && exist[j] != -1; j = fail[j]) {
			res += exist[j]; exist[j] = -1;
		}
	}
	return res;
}
int main() {
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int n; cin >> n; cin.ignore();
	while (n--) {
		string p; cin >> p;
		add(p, p.size());
	}
	build();
	string s; cin >> s;
	cout << query(s, s.size()) << '\n';
}

二次加强版

#include<iostream>
#include<algorithm>
#include<cmath>
#include<string.h>
#include<string>
#include<queue>
#include<ctime>
#include<vector>
//#define int long long
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = 1e6 + 7;
const int mod = 1e9 + 7;
const int INF = (1 << 31) - 1;
int tire[maxn][26], cnt;
bool exist[maxn];
int mrk[maxn], res[maxn];
int pos[maxn];
int fail[maxn];
struct edge {
	int to, nxt;
};
edge e[maxn];
int head[maxn], tot;
void add(int from, int to) {
	e[++tot].to = to; e[tot].nxt = head[from]; head[from] = tot;
}
int insert(string s,int len) {
	int path = 0;
	for (int i = 0; i < len; ++i) {
		int ch = s[i] - 'a';
		if (tire[path][ch] == 0)tire[path][ch] = ++cnt;
		path = tire[path][ch];
	}
	exist[path] = 1;
	return path;
}
void build() {
	queue<int> Q;
	for (int i = 0; i < 26; ++i) {
		if (tire[0][i]) {
			Q.push(tire[0][i]);
			add(0, tire[0][i]);
		}
	}
	while (!Q.empty()) {
		int from = Q.front(); Q.pop();
		for (int i = 0; i < 26; ++i) {
			if (tire[from][i]) { 
				fail[tire[from][i]] = tire[fail[from]][i]; 
				Q.push(tire[from][i]);
				add(tire[fail[from]][i], tire[from][i]);
			}
			else tire[from][i] = tire[fail[from]][i];
		}
	}
}
void query(string s, int len) {
	int path = 0;
	for (int i = 0; i < len; ++i) {
		char ch = s[i] - 'a';
		path = tire[path][ch];
		mrk[path]++;
	}
}
int dfs(int from,int fa) {
	for (int i = head[from]; ~i; i = e[i].nxt) {
		int& to = e[i].to;
		if (to != fa)mrk[from] += dfs(to, from);
	}
	return mrk[from];
}
string s[maxn];
signed main() {
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	memset(head, -1, sizeof(head));
	int n; cin >> n;
	for (int i = 1; i <= n; ++i) { 
		cin >> s[i]; 
		int d = insert(s[i], s[i].length());
		pos[d] = i; res[i] = d;
	}
	string p; cin >> p;
	build();
	query(p, p.size());
	dfs(0, -1);
	for (int i = 1; i <= n; ++i) {
		cout << mrk[res[i]] << '\n';
	}
}
qwq_,有什么不足的地方欢迎大家指正。