字符串 - AC 自动机

这里有一些别样的学习思路。

KMP

用途

单模式串匹配。

过程

我们分解 \(O(nm)\) 的算法过程。

如图，红色竖线包括的为目前匹配成功的部分，对于下一位 \(i\) ：

首先，如果成功匹配，那么匹配长度加一。

否则，我们考虑失配情况。

我们会将 \(S\) 串的匹配部分左端点向右移动一位，然后 \(T\) 串从头匹配。

我们发现，如果想要再次考虑第 \(i\) 位，最起码需要匹配到如上图中红色横线的部分，也就是说红色横线的部分完全相等。

如果不完全相等，我们需要比较绿色横线的部分，如此以往。

要么，我们找到了另一个起点，使得我们可以重新考虑第 \(i\) 位的匹配情况。
要么，我们遍历了所有的起点，不存在这种情况，即第 \(i\) 位前不存在可以拼接上 \(i\) 的后缀，我们就以第 \(i\) 位为起点开始重复这个过程。

可以发现，第一种情况中，我们一定找到了红色竖线内的 \(T\) 串 的 最长公共前后缀。

也就是说，当失配时，我们只需要知道，当前已匹配 \(T\) 串部分（一定是 \(T\) 的前缀）的最长公共前后缀。
如果仍然失配，我们继续找到 \(T\) 的最长公共前后缀的最长公共前后缀，重复此过程。

• 一个字符串 \(S\) 的 最长公共前后缀 为 \(S\) 的长度最长的真子串 \(T\)，满足 \(T\) 既是 \(S\) 的前缀，也是 \(S\) 的后缀，以下称作 \(\texttt{boarder}\)。

由此，我们便建立了较为完整的思维过程来优化此算法。

可以发现，我们尽可能地减少了重复的，或者说无意义的比较，算法的 正确性 由此保证。

\(\texttt{boarder}\) 求法

我们用红色横线表示第 \(i - 1\) 位的 \(\texttt{boarder}\)。
可以发现，此过程类似于 \(T\) 的自身匹配，与上述优化过程类似。
请读者自行推导本过程。

时间复杂度

首先来看两主要部分代码：

for (int i = 2, j = 0; i <= M; ++i) {
	while (j and t[j + 1] != t[i]) j = p[j];
	if (t[j + 1] == t[i]) ++j;
	p[i] = j;
}
for (int i = 1, j = 0; i <= N; ++i) {
	while (j and s[i] != t[j + 1]) j = p[j];
	if (s[i] == t[j + 1]) ++j;
	if (j == M) ans.push_back(i - M + 1), j = p[j];
}
//Luogu P3375

以 \(\texttt{boarder}\) 的处理为例，我们发现，变量 \(j\) 最多增量为 \(O(n)\)，也就最多向前 跳 \(O(n)\) 次，复杂度为 \(O(n)\)。
匹配过程同理。

如果 \(\left| S \right| = n, \left| T \right| = m\)
则总时间复杂度 \(O(n + m)\)。

AC 自动机

用途

多模式串匹配。

引入

我们考虑暴力方式，因为是多模式串，我们需要对模式串建一棵 \(Tire\) 树。
（\(Tire\) 树不在此处涉及，已默认各位学过 \(Tire\) 树）

然后对于匹配串，我们对于它的每一个前缀 \(T\)，\(S\) 为 \(Tire\) 树上存在的 \(T\) 的最长后缀。
\(Tire\) 树上代表 \(S\) 的结点到根路径上的所有尾结点答案加一。

这是我们的暴力思路。

可以发现，制约复杂度的最大因素是找 \(S\) 串的过程，我们尝试优化这个过程。

增量，当前处理完的前缀为 \(T'\)，得到的最长后缀为 \(S\)，下一位考虑的字符为 \(c\)。
如果 \(S\) 拼接上 \(c\) 后仍然可以在 \(Trie\) 树上找到，直接继承。
否则，我们需要找到 \(S\) 在 \(Tire\) 树上存在的每一个后缀，
（因为只有后缀在 \(Trie\) 树上存在，再拼接一个字符才可能在 \(Trie\) 树上）
可以发现这和之前的 \(KMP\) 算法过程类似。

为了加快这个进程，我们需要和 \(KMP\) 的 \(\texttt{boarder}\) 类似的东西， \(\texttt{Fail}\) 指针。
具体的

• 一个 \(Trie\) 树结点的 \(\texttt{Fail}\) 指针指向 此结点存在于 \(Trie\) 树上的最长严格后缀。
  （为了语言简洁，之后皆省略不必要话术）

构造 \(\texttt{Fail}\) 指针

容易发现，一个结点的 \(\texttt{Fail}\) 指针指向结点深度一定小于自己，所以采用 bfs 来构建 \(Fail\) 指针。

本人比较喜欢用 \(0\) 号结点来表示 \(Tire\) 树 的根。
那么，最开始的时候，将根的所有子结点加入队列。
对于每一个点，我们执行如下操作：

当前结点的每一个子结点，它的 \(\texttt{Fail}\) 指针可能指向 当前结点的 \(\texttt{Fail}\) 指针指向结点 \(\left(v\right)\) 的对应子结点。
如果为空，则可能为 结点 \(v\) 的 \(\texttt{Fail}\) 指针指向结点的对应子结点 \(\left( v' \right)\)，如此类推。
如果都为空，则 \(Fail\) 指针指向根节点。
将子结点加入队列。

同时，我们发现，这样跳 \(\texttt{Fail}\) 指针的操作其实时间上是很劣的，我们仍然可以对其进行部分优化。
这里我们使用 路径压缩 的思想。

对于每个节点 \(u\)，我们对它的 \(ch[u][k]\) 数组定义做出修改，实质仍是一个指针数组，不过：
（我们将不进行定义修改构造出的 \(Tire\) 树叫做朴素 \(Tire\) 树）

如果朴素 \(Tire\) 树上 \(ch[u][k]\) 不为空，则 \(ch[u][k]\) 值与朴素 \(Tire\) 树相同；
否则，如果 \(ch[u][k]\) 为空，但朴素 \(Tire\) 树中存在异于 \(u\) 的一个结点 \(v\) 表示的前缀 \(S\)，是 \(u\) 表示前缀 \(T\) 的后缀，且 \(S\) 最长， \(ch[u][k]\) 指向 \(v\)。
否则， \(ch[u][k]\) 为空。

\(\texttt{Fail}\) 指针定义不变。

所以，我们可以得到如下代码

void B() {
    std::queue <int> d;
    lep(k, 0, 25) if (ch[0][k]) d.push(ch[0][k]);
    while (!d.empty()) { int u = d.front(); d.pop();
        lep(k, 0, 25) {
            if (ch[u][k]) fail[ch[u][k]] = ch[fail[u]][k], d.push(ch[u][k]);
            else ch[u][k] = ch[fail[u]][k];
        }
    }
}

由于全部绘出指针的图片太过杂乱而难以理解，我们只针对其中的局部过程，争取获得对算法的整体把握。
（红色箭头为 \(\texttt{Fail}\) 指针，绿色箭头为改变定义后新增的用于路径压缩的指针）。
（注：编号只是为了区分结点，与实际 \(Tire\) 编号不一定相同）。

统计答案

可以发现，我们需要一个后缀和来统计答案，所以我们根据 \(\texttt{Fail}\) 指针来建一棵树，进行子树累加操作。
读者可自行考虑为什么这样可以遍历到所有后缀。

void D(int u) { for (int v : e[u]) D(v), sum[u] += sum[v]; }
void G(char s[]) {
    int len = std::strlen(s + 1), nw = 0;
    lep(i, 1, len) nw = ch[nw][s[i] - 'a'], ++sum[nw];
    lep(i, 1, idx) e[fail[i]].push_back(i);
    D(0);
    lep(i, 1, n) printf("%d\n", sum[ps[i]]);
}