AC自动机与后缀自动机详解-优快云博客

本文链接：https://blog.youkuaiyun.com/ez_lcw/article/details/106096810

~~只是给忘记模板时的我看的~~

AC自动机

大概流程

首先对所有模式串建出 $T r i e$ 树，并标记。

$f a i l$ 的定义：设 $i$ 节点所代表的字符串为 $S$ ，则 $fail_i$ 表示 $S$ 的所有后缀里面，在 $T r i e$ 树中出现过的最长的那个串所代表的节点。

然后通过 $\texttt{bfs}$ 求出 $f a i l$ ，代码如下：

void getfail()
{
	queue<int>q;
	for(int i=0;i<26;i++)
		if(t[0].ch[i])
			q.push(t[0].ch[i]);
	while(!q.empty())
	{
		int u=q.front();
		q.pop();
		for(int i=0;i<26;i++)
		{
			if(t[u].ch[i])
			{
				t[t[u].ch[i]].fail=t[t[u].fail].ch[i];
				q.push(t[u].ch[i]);
			}
			else t[u].ch[i]=t[t[u].fail].ch[i];//tag1
		}
	}
}

其中为什么 $tag_1$ 处可以将 $u$ 的儿子直接指向 $fail_u$ 的儿子 $v$ ：

首先实际的操作应该是新建一个虚拟节点 $n e w$ ，使 $n e w$ 为 $u$ 的儿子，且 $fail_{new}=v$ 。

又由于 $n e w$ 本身是新建的节点，没有任何儿子，所以 $n e w$ 的儿子全都是要靠新建虚拟节点构成。

所以 $n e w$ 的子树其实和 $v$ 的子树是一模一样的。

那我们不妨用同一棵子树表示他们，也就是说让 $u$ 的儿子指向 $v$ 而不是新建节点。

然后由于 $n e w$ 树的 $f a i l$ 全部都是指向 $v$ 树的，所以合并到一起不会对 $f a i l$ 产生影响。

那么 $\operatorname{getfail}()$ 之后原来的 $T r i e$ 树就会变成一个 DAG 了。

实际应用

一、模式串与文本串匹配上的应用

原理

首先通过递归 $f a i l$ ，就可以遍历某个串的所有在模式串中出现过的后缀。

同样，如果建立 $f a i l$ 树（ $fail_i\to i$ ），就可以通过遍历某一个点 $u$ 的子树（设 $u$ 所代表的串为 $s$ ），遍历所有以 $s$ 为后缀的串。（也就是往 $s$ 的前面加字符）

其次，对于原 $T r i e$ 树中的某一个节点 $u$ （设其代表的串为 $s$ ），可以遍历统计 $u$ 子树内的所有点，遍历所有以 $s$ 为前缀的串。（也就是往 $u$ 后面加字符）

那么综合上面两个操作，对于某个串 $t$ ，我们可以求出所有满足 $t$ 是 $s$ 的子串的 $s$ 串的信息。

时间复杂度为 $O (n)$ （遍历一遍 $T r i e$ 树+一遍 $f a i l$ 树）。

所以对于解决模式串类的问题，AC 自动机的本质就是对于每一种字符串，除了记录在它后面加字符能到达的出现过的串（ $T r i e$ 树），还记录了在它前面加字符能到达的出现过的串（ $f a i l$ 树）。

那么对于 $s$ 串的子串信息，我们可以对 $s$ 的前缀跳 $f a i l$ 链。而对于 $t$ 串的扩展串信息（ $t$ 是某个串的子串），我们可以在 $f a i l$ 树中遍历 $t$ 树的子树，再在 $T r i e$ 树中遍历遍历到的点的子树。

例题

1.请你分别求出每个模式串 $T_i$ 在文本串 $S$ 中出现的次数。

可以直接按我们刚刚的做法来做（跳 $S$ 前缀的 $f a i l$ 链），但是会 T 飞。

考虑优化，把根到 $S$ 路径上的节点都标记（设为 $s i z e = 1$ ），然后建立 $f a i l$ 树（ $fail_i \to i$ ），设 $size_i$ 为 $i$ 这个节点所代表的字符串在 $S$ 中出现的次数。

那么在 $f a i l$ 树中， $i$ 的子树中的所有有效节点都能为 $size_i$ 贡献 $1$ 。所以把每一个有效节点 $s i z e$ 的初始值都设为 $1$ 然后在 $f a i l$ 树上从下往上统计 $s i z e$ 。

#include<bits/stdc++.h>

#define N 200010
#define ll long long

using namespace std;

struct Trie
{
	int ch[26],fail;
	ll size;
}t[N];

int n,node,id[N];
int cnt,head[N],nxt[N],to[N];

void adde(int u,int v)
{
	to[++cnt]=v;
	nxt[cnt]=head[u];
	head[u]=cnt;
}

int insert(string s)
{
	int u=0,len=s.size();
	for(int i=0;i<len;i++)
	{
		int v=s[i]-'a';
		if(!t[u].ch[v]) t[u].ch[v]=++node;
		u=t[u].ch[v];
	}
	return u;
}

void dfsTrie(string s)
{
	int u=0,len=s.size();
	for(int i=0;i<len;i++)
	{
		int v=s[i]-'a';
		u=t[u].ch[v];//这里可能没有u->v这个转移然后回到根，但也是对的。因为这代表在Trie树中没有出现任何一个s[1...i]的后缀（注意这里的转移时geifail后的）
		t[u].size++;
	}
}

void getfail()
{
	queue<int>q;
	for(int i=0;i<26;i++)
		if(t[0].ch[i])
			q.push(t[0].ch[i]);
	while(!q.empty())
	{
		int u=q.front();
		q.pop();
		for(int i=0;i<26;i++)
		{
			if(t[u].ch[i])
			{
				t[t[u].ch[i]].fail=t[t[u].fail].ch[i];
				q.push(t[u].ch[i]);
			}
			else t[u].ch[i]=t[t[u].fail].ch[i];
		}
	}
	for(int i=1;i<=node;i++)
		adde(t[i].fail,i);
}

void dfsFail(int u)
{
	for(int i=head[u];i;i=nxt[i])
	{
		int v=to[i];
		dfsFail(v);
		t[u].size+=t[v].size;
	}
}

int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		string str;
		cin>>str;
		id[i]=insert(str);
	}
	getfail();
	string s;
	cin>>s;
	dfsTrie(s);
	dfsFail(0);
	for(int i=1;i<=n;i++)
		printf("%lld\n",t[id[i]].size);
	return 0;
}
/*
3
abc
cde
de
abcde
*/

2.https://blog.youkuaiyun.com/ez_lcw/article/details/99613063

后缀自动机（SAM）

大概流程

（以下的 “节点” 均表示后缀自动机中的节点）

（定义对于两个字符串 $A, B$ 的运算 $A + B$ 表示 $A$ 和 $B$ 顺次拼接起来的串）

（下面请注意 $S (i)$ 和 $S [i]$ 的区别，其中后者表示字符串 $S$ 的第 $i$ 位，而前者在下文中会有定义）

$\operatorname{Endpos}$ 集合

我们把 $S$ 的一个子串在 $S$ 中每一次出现的结束位置的集合定义为 $\operatorname{Endpos}$ 集合。

然后我们考虑我们要构建的后缀自动机长什么样：我们将 $\operatorname{Endpos}$ 集合完全相同的子串合并到同一个节点。

我们发现，对于越短的子串，其 $\operatorname{Endpos}$ 集合往往越大。更具体地，如果 $t$ 是某一个子串 $T$ 的后缀，则 $|\operatorname{Endpos}(t)|\geq |\operatorname{Endpos}(T)|$ 。当且仅当取等号时， $t$ 和 $T$ 会被压缩到同一个节点中。

而对于某一个子串 $T$ 来说，肯定有一个分界长度 $l e n$ ，使得每一个长度 $\geq len$ 的 $T$ 的后缀的 $\operatorname{Endpos}$ 都和 $\operatorname{Endpos}(T)$ 相同（所以这些后缀和 $T$ 在同一个节点），且每一个长度 $< l e n$ 的 $T$ 的后缀的 $\operatorname{Endpos}$ 大小都比 $\operatorname{Endpos}(T)$ 大（所以这些后缀和 $T$ 不在同一个节点，而且这些后缀可能在不同的节点）。

所以每个节点 $u$ 中存储的一定是一堆长度连续的子串，且短的串是长的串的后缀。不妨把这些串的集合称为 $S (u)$ ，设其中最长的串为 $\operatorname{longest}(u)$ ，最短的串为 $\operatorname{shortest}(u)$ 。

我们在具体实现时会用一个 $l e n$ 数组记录每个节点中最长的子串的长度（即 $\operatorname{longest}(u)$ 的长度），为什么不用记最短的长度，下文会讲。

Parent Tree

如上文所述，对于每一个子串都会有唯一一个 ”分界长度“，而且每一个节点中所有子串的 “分界长度” 都相同，为这个节点中最短的子串的长度。

而如果 $t$ 是 $T$ 的一个后缀且没有和 $T$ 分在一个节点中，那么 $t$ 肯定也是别的子串的后缀，例如 $\texttt{ab}$ 在串 $\texttt{cabzab}$ 中既可以是 $\texttt{cab}$ 的后缀，也可以是 $\texttt{zab}$ 的后缀。这样我们看到：长的串 $T$ 只能 “对应” 唯一的一个短的串 $t$ ，而短的串可以 “对应” 多个长的串，如果将 “短的串” 视为 “长的串” 的父亲，这就构成了一棵严格的树形结构。我们称为Parent Tree。

形式化地说，对于一个节点 $u$ ，我们找到 $S (u)$ 中某一个子串 $T$ 的后缀 $t$ ，使得 $t$ 不在 $\operatorname{S}(u)$ 中且满足 $∣ t ∣$ 最大（显然 $t$ 是 $S (u)$ 中任何一个串的后缀且 $∣ t ∣$ 等于 $S (u)$ 中任何一个串的 “分界长度“ 减 $1$ ），记 $u$ 的后缀链接 $\operatorname{link}(u)$ 为 $t$ 所属的节点。那么 $\operatorname{link}$ 所构成的就是这个 Parent Tree。

这时你会发现 $\operatorname{shortest}(u)$ 的长度其实就是 $\operatorname{longest}(\operatorname{link}(u))$ 的长度加 $1$ ，即 $len(\operatorname{link}(u))+1$ ，所以我们无需记录 $\operatorname{shortest}(u)$ 的长度。

SAM 的转移

对于一个节点 $u$ ，在 $S (u)$ 中的某一个串后面添加一个字符 $c$ 变成一个新的串，如果这个新的串仍是 $S$ 的子串（那么由于 $S (u)$ 中的任意一个串在 $S$ 的某个位置出现， $S (u)$ 中的其他串肯定也会在同样位置出现，所以此时 $S (u)$ 中的所有串添加这个字符 $c$ 所形成的的新串也都仍是 $S$ 的子串 ${\,}^{(1)}$ ），设这个新串所属的节点为 $p$ ，那么我们记录转移 $ch[u][c]\gets p$ 。

注意对于添加字符 $c$ 而言，添加 $c$ 后的新串可能不同，但它们的 $\operatorname{Endpos}$ 都是相同的，因为新串中的某一个串在某个位置出现，那么将它末尾的 $c$ 删除后， $S (u)$ 中的其他串也肯定会在同样位置出现，然后再加上末尾的 $c$ ，于是所有的新串也都会在同样的位置出现。这同时说明了 $c h [u] [c]$ 是唯一的 ${\,}^{(2)}$ 。

但注意这些新串所属的等价类 $S (c h [u] [c])$ 不一定只包含这些新串 ${\,}^{(3)}$ 。同时也说明了有可能有多个 $c h [u] [c]$ 指向同一个点，于是 SAM 实际上是一个 DAG。

算法（实现）

考虑从前往后加入 $S$ 的每一个字符，假设当前加入的是 $c = S [x]$ 。

加入字符 $c$ 的实际操作是把 $S [1 . . x]$ 的所有后缀的 $\operatorname{Endpos}$ 集合都改变了（新增加了元素 $x$ ），考虑这将如何影响后缀树的形态，那么我们先要找到 $S [1 . . x]$ 的所有后缀所在的节点。

那我们肯定要先新建一个节点 $n o w$ 表示 $S [1 . . x]$ 的 $\operatorname{Endpos}$ 等价类，因为这个等价类之前一直没有出现过。

我们上一次插入 $S [x - 1]$ 的时候肯定也新建了一个节点表示 $S [1 . . x - 1]$ 的 $\operatorname{Endpos}$ 等价类，记这个节点为 $l a s t$ 。

根据 $(1)$ ，由于 $S [1 . . x]$ 是 $S [1 . . x - 1]$ 末尾添加字符 $c$ 后得到的串，那么 $S (l a s t) + c$ 的所有串都应该属于同一个 $\operatorname{Endpos}$ 等价类，于是直接 $ch[last][c]\gets now$ 。

接着，令 $p = l a s t$ ，然后让 $p$ 沿着 $\operatorname{link}$ 往上跳，并且一直记录 $ch[p][c]\gets now$ ，直到满足已经存在转移 $c h [p] [c]$ 了（此时证明 $S [1 . . x - 1]$ 中出现过 $S [1 . . x]$ 的后缀）。

让 $p$ 一直往上跳的过程实际上相当于从长到短枚举 $S [1 . . x - 1]$ 后缀中的每一种 $\operatorname{Endpos}$ 定价类，也就相当于把 $S [1 . . x - 1]$ 的所有后缀都枚举一遍，而判断是否已经存在转移 $c h [p] [c]$ 也就相当于把 $S [1 . . x]$ 的每一个后缀都枚举了一遍（因为满足一个串 $T$ 是 $S [1 . . x]$ 的后缀的必要条件是 $T$ 去掉最后一位后是 $S [1 . . x - 1]$ 的后缀），并判断它们是否在 $S [1 . . x - 1]$ 中出现过。

所以如果跳到某个 $p$ 仍然不存在转移 $c h [p] [c]$ ，即 $S (p) + c$ （显然这是 $S [1 . . x]$ 的一段长度连续的后缀）没有在 $S [1 . . x - 1]$ 中出现过，那么 $S (p) + c$ 的 $\operatorname{Endpos}$ 集合和 $S [1 . . x]$ 的是一样的，即 $S (p) + c$ 包含于 $S (n o w)$ ，于是我们直接令 $ch[p][c]\gets now$ ，再继续往上跳即可。

接下来我们分情况讨论：

如果就这么顺着 Parent Tree 跳一直跳到了根节点还要往上，此时证明 $S [1 . . x]$ 的任何一个后缀都没有在 $S [1 . . x - 1]$ 中出现过，那么我们直接让 $\operatorname{link}(now)=rt$ 即可。
否则，如果我们在跳的过程中找到了一个 $p$ 使得已经存在转移 $c h [p] [c]$ 了，我们就先设 $q = c h [p] [c]$ 。

但注意此时仅满足 $S (p) + c$ 包含于 $S (q)$ ，所以并不一定是 $S (q)$ 中所有串的 $\operatorname{Endpos}$ 集合都改变了，即 $S (q)$ 里面不一定全是 $S [1 . . x]$ 的后缀。

可以发现 $S (q)$ 中所有 $\operatorname{longest}(p)+c$ 的后缀（即 $S (q)$ 中所有长度小于等于 $l e n (p) + 1$ 的串）都是 $S [1 . . x]$ 的后缀（尽管这些串中可能有长度短的一部分并不属于 $S (p) + c$ ，但他们仍然是 $S [1 . . x]$ 的后缀，我们一起考虑），它们的 $\operatorname{Endpos}$ 集合都改变了。

同时 $S (q)$ 中所有长度大于 $l e n (p) + 1$ 的串都一定不是 $S [1 . . x]$ 的后缀（因为这个 $p$ 使我们最先找到的，即 $\operatorname{longest}(p)+c$ 应该是 $S [1 . . x]$ 在 $S [1 . . x - 1]$ 中出现的最长的后缀），它们的 $\operatorname{Endpos}$ 集合都没有改变。

然后我们再分情况讨论：
- 若 $l e n (q) = l e n (p) + 1$ ，我们直接令 $\operatorname{link}(now)\gets q$ 即可，上面已经证明了这样的 $q$ 一定是最长的。
- 若 $len(q)\neq len(p)+1$ ，此时 $\operatorname{longest}(q)$ 不是 $S [1 . . x]$ 的后缀，而且 $\operatorname{longest}(q)$ 会比 $\operatorname{longest}(p)$ 长一截。
  
  那么此时 $S (q)$ 中长度大于 $l e n (p) + 1$ 和长度小于等于 $l e n (p) + 1$ 的两部分串的 $\operatorname{Endpos}$ 集合已经不同了，需要分离。
  
  于是我们新建一个点 $n q$ ，表示 $S (q)$ 中长度小于等于 $l e n (p) + 1$ 的那一部分串的 $\operatorname{Endpos}$ 等价类。这样就在 $q$ 和 $f=\operatorname{link(q)}$ 之间新插入了一个点，所以 $\operatorname{link}(q)\gets nq$ ， $\operatorname{link}(nq)\gets f$ 。同时更新 $len(nq)\gets len(p)+1$ 。也要更新 $ch[nq]\gets ch[q]$ （更新 $ch[nq]\gets ch[q]$ 的原因上面 $(1)$ 处有提到）。
  
  同时要让 $\operatorname{link}(now)\gets nq$ ，上面同样也已经证明了这样找到的 $n q$ 一定是最长的。
  
  最后，我们就要更新我们还要继续让 $p$ 沿着 $\operatorname{link}$ 往上跳，如果 $c h [p] [c] = q$ ，那么更新 $ch[p][c]\gets nq$ （这里这么更新的证明比较显然，略去），否则停止上跳退出。
然后就结束了吗？ $q$ （ $n q$ ）在 Parent Tree 上的祖先（即 $p$ 在 Parent Tree 上的祖先往 $c$ 的转移）的 $\operatorname{Endpos}$ 集合都有改变，它们不需要更新吗？事实上由于这些点所包含的所有串的 $\operatorname{Endpos}$ 集合都同样增加了一个元素 $x$ （而且由于增加的元素为 $x$ ，所以这些点的转移不可能有更新），于是经过若干推导可知 SAM 的结构并没有改变，所以我们无需更新。

这样 SAM 就建好了。

实际应用

咕咕咕……

后缀树

定义

后缀树定义比 SAM 简单很多。对于串 $S$ 的后缀树，我们先把串 $S$ 的所有后缀各加入一个终止符后都插入到一棵 Trie 树中，比如对于串 $\texttt{banana}$ ，将得到下面这么一棵 Trie 树：（图来自于 EA’s blog）

在这里插入图片描述

但这样节点数是 $O(n^2)$ 的，但我们发现这棵 Trie 树上有很多节点只有一个儿子，这样构成了若干条单链，我们可以把这些链进行压缩，变成这样：

在这里插入图片描述

这样压缩后的字典树我们就把它称为后缀树。

这样的后缀树的节点数量是 $O (n)$ 级别的，因为它只有 $n$ 个叶子（终止符），而且每个点的儿子个数都大于 $1$ ，于是就能用类似虚树的方式证明出这棵树的节点至多只有 $2 n - 1$ 个。

再根据等一下会说的结论，这也侧面证明了 SAM 的节点个数至多为 $2 n - 1$ 个。

构建

直接构建后缀树有 Ukkonen 算法，但是实际上我们可以用 SAM 来构建。

结论：串 $S$ 在 SAM 上的 Parent Tree 为串 $S$ 的反串的后缀树。

假设现在有某个串 $S^{'}$ ，我们先定义 $S^{'}$ 的某个子串在 $S^{'}$ 中出现的所有位置的左端点集合为 $\operatorname{leftpos}$ 集合。这个定义和 $\operatorname{Endpos}$ 类似。

然后你发现后缀树上的一条边就代表着一个 $\operatorname{leftpos}$ 等价类，因为这条边上的所有点都没有分支，意味着对于这条边上的任意两个长度相差 $1$ 串 $A, A + c$ ， $A$ 只会出现在 $A + c$ 中，否则若 $A$ 还出现在 $A + c^{'}$ 中那么就会有 $c^{'}$ 这个分支，就矛盾了。

于是后缀树上的一个点 $u$ 就能代表它往父亲的那条边的 $\operatorname{leftpos}$ 等价类，于是可以类似地定义 $\operatorname{longest}'(u)$ 表示 $u$ 所代表的 $\operatorname{leftpos}$ 等价类中的所有串中最长的那个，显然 $u$ 中的其他串都是 $\operatorname{longest}'(u)$ 的前缀。

而且对于后缀树上点 $u$ 的父亲 $f$ ，肯定有 $\operatorname{longest}'(f)$ 是 $\operatorname{longest}'(u)$ 的所有前缀中和 $\operatorname{longest}'(u)$ 不属于同一个 $\operatorname{leftpos}$ 集合的最长的前缀。