AC自动机
AC自动机
前置芝士
- kmp
- trie
介绍
学算法首先肯定要清楚这个算法是用来解决啥东西的。
AC 自动机是用线性的复杂度来解决多模匹配的算法。
额(⊙o⊙)，说人话就是例如给你一堆字符串（称为模式串）和一个字符串（称为文本串），让你求模式串们在文本串出现的总次数。
来直接看模板题：
题目描述
给定 \(n\) 个模式串 \(s_i\) 和一个文本串 \(t\)，求有多少个不同的模式串在文本串里出现过。
两个模式串不同当且仅当他们编号不同。
对于 \(100\%\) 的数据，保证 \(1 \leq n \leq 10^6\)，\(1 \leq |t| \leq 10^6\)，\(1 \leq \sum\limits_{i = 1}^n |s_i| \leq 10^6\)。\(s_i, t\) 中仅包含小写字母。
那么好，现在应该很清楚了，这不就是 kmp 的模板题中模式串变多了亿点点吗？如果每个模式串分开匹配，平方级别复杂度，直接爆炸。众所周知：
我们要做的是把所有的模式串建立一个 trie，然后在 trie 上跑 kmp。
可以回想一下 kmp 匹配的过程。有一个数组 \(fail\)，或者是 \(next\)（以下简称为 \(f\)）。
它的含义有很多，本质上 \(f[i]\) 是指：模式串 \(s\) 的下标为 \(i\) 的位置失配时，模式串的指针应该返回的下标。
如果将 \(f\) 数组的所有值向前移动一位，那么他的含义就可以变为：在以 \(s[i]\) 结尾的前缀中，它的真后缀能匹配到的最长前缀的长度。这也是我们求 \(f\) 数组的关键。
这样的话，在失配的情况下，指针回跳的次数就能最少，可以保证线性的复杂度。
类比一下，trie 上的 kmp 也是一样的 \(f[i]\) 是指：下标为 \(i\) 的位置失配时，模式串的指针应该返回的下标。
现在已经匹配完了节点 \(i\)，接下来要匹配它的子节点，如果失配（或者匹配完了），说明这一条路就不必继续走了，要换一条。而从根节点到 \(i\) 都是匹配的，我就可以跳到 \(j\) 上，使得 \(root\) 到 \(j\) 是 \(root\) 到 \(i\) 的真后缀能匹配到的从根开始的最长前缀，以保证回跳次数最少。
是不是和 kmp 几乎一样？这样，跳到 \(j\) 的位置，继续匹配 \(j\) 的子节点。其实就是在匹配一个模式串时不行，直接换一个继续。都不行就返回根从头来过。这样解释就十分贴切于 kmp 了。
kmp 其实可以看作 trie 为一条链的 AC 自动机。
举个例子：
she
he
say
shr
her
trie 图为：
绿色的箭头就是 \(fail\) 指针，根据定义：
f[2]=4
f[3]=5
f[6]=0
比如在二号节点失配，那么 \(s\) 和 \(h\) 肯定是匹配好了的，所以返回四号节点，继续匹配。
操作
insert
主要就是建立 trie 的过程，和模板一样的，就不多解释了。
// 这里p为下标，tr为节点编号，tot为节点总数
void insert(string x)
{
int p=0;
for(auto c:x)
{
int u=c-'a';
if(!tr[p][u]) tr[p][u]=++tot;
p=tr[p][u];
}
cnt[p]++;//这里要视情况而定
}
build
\(fail\) 的含义上面已经说清楚了，现在就要解决如何去求得 \(fail\) 数组。
先看到 kmp 是如何求的：
int i=1,j=0;
while(i<s.size())
{
//j=f[i-1];
while(j&&s[i]!=s[j]) j=f[j];
if(s[i]==s[j]) j++;
f[++i]=j;
}
当然会有其他的写法，不过也大同小异。注意看注释掉的一行，注释的原因是因为这就是我们上一次循环求得的 \(j\)，不需要再赋一遍值。但加上后这个过程就会更加清晰。
还是拿这个例子。
绿色表示已经匹配好了的可以继续用的，红色表示即将要匹配的。
可以看到，要是红色的匹配成功了，自然绿色部分长度加一；若是不成功，就要保证 \(i\) 位置上前面的绿色部分尽可能多，所以再跳一次。不行的话，继续跳，直到 \(0\) 也不成功。这时 \(f[i]=0\)。
也就是说我们要用到上一个位置的 \(f\) 值，递推的去求。而在 trie 上，就可以用 BFS 逐层去求 \(f\) 数组。
至于代码，直接对应 kmp 写就好了，注意第一层的 \(f\) 肯定是 \(0\)。
queue<int> q;
void build()
{
for(int i=0;i<26;i++)
if(tr[0][i])
q.push(tr[0][i]);//根的儿子都为0，直接入队
while(!q.empty())
{
int u=q.front();q.pop();
for(int i=0;i<26;i++)//遍历下一层的所有儿子
{
int v=tr[u][i],j=f[u];//j=f[i-1];
while(j&&!tr[j][i]) j=f[j];//while(j&&s[i]!=s[j]) j=f[j];
if(tr[j][i]) j=tr[j][i];//if(s[i]==s[j]) j++;
f[v]=j;//f[++i]=j;
}
}
}
一模一样对吧？等一等，怎么感觉不太对，为啥别人的代码没有 for 里面的 while？
其实 AC 自动机有一个优化，就是把这个 while 优化掉的。优化后也叫做 trie 图。也就是我们一般所写的形式，统称为 AC 自动机。优化只是优化常数，优化前后其实都是线性的复杂度。
那么好，问题就在于 while。匹配 \(u\) 的儿子 \(i\) 的时候 \(f[u]\) 的儿子里没有 \(i\)，就要往上跳。
这里就可以用类似并查集中路径压缩的方法，将信息存在没有的虚点中，在匹配失败后对号入座就好了。
queue<int> q;
void build()
{
for(int i=0;i<26;i++)
if(tr[0][i])
q.push(tr[0][i]);
while(!q.empty())
{
int u=q.front();q.pop();
for(int i=0;i<26;i++)
{
int v=tr[u][i],j=f[u];
if(!v) tr[u][i]=tr[j][i];//若失败，继承信息
else f[v]=tr[j][i],q.push(v);//若成功，直接赋值
}
}
}
这就是 AC 自动机建立的终极形态 QWQ。
查询
明白了重点以后，这个就简单很多了，也是由 kmp 的代码直接推过来。
为避免重复，用 \(-1\) 来标记。
只不过当匹配到一个后，它的前缀也要统计答案，而前缀中可能出现的都应该在 \(f\) 里面，所以一直跳直到根统计答案就好了。
int query(string x)
{
int p=0,ans=0;
for(auto c:x)
{
int u=c-'a';
while(p&&!tr[p][u]) p=f[p];//while(j&&t[i]!=s[j]) j=f[j];
if(tr[p][u]) p=tr[p][u];//if(t[i]==s[j]) j++;
int j=p;
while(j&&cnt[j]!=-1)
{
ans+=cnt[j]；
cnt[j]=-1;
j=f[j];
}
}
return ans;
}
和 build 同理，这也可以优化，就直接变成了：
int query(string x)
{
int p=0,ans=0;
for(auto c:x)
{
int u=c-'a';
p=tr[p][u];//省去while
int j=p;
while(j&&cnt[j]!=-1)
{
ans+=cnt[j]；
cnt[j]=-1;
j=f[j];
}
}
return ans;
}
code
完整代码：
#include <bits/stdc++.h>
using namespace std;
const int N=1e6+5;
queue<int> q;
int n,tot;
int tr[N][26],cnt[N],f[N];
string s;
void insert(string x)
{
int p=0;
for(auto c:x)
{
int u=c-'a';
if(!tr[p][u]) tr[p][u]=++tot;
p=tr[p][u];
}
cnt[p]++;
}
void build()
{
for(int i=0;i<26;i++)
if(tr[0][i])
q.push(tr[0][i]);
while(!q.empty())
{
int u=q.front();q.pop();
for(int i=0;i<26;i++)
{
int v=tr[u][i],j=f[u];
if(!v) tr[u][i]=tr[j][i];
else f[v]=tr[j][i],q.push(v);
}
}
}
int query(string x)
{
int p=0,ans=0;
for(auto c:x)
{
int u=c-'a';
p=tr[p][u];
int j=p;
while(j&&cnt[j]!=-1)
{
ans+=cnt[j];
cnt[j]=-1;
j=f[j];
}
}
return ans;
}
int main ()
{
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>s;
insert(s);
}
build();
cin>>s;
cout<<query(s)<<"\n";
return 0;
}
拓扑建图优化
代填的坑 qwq。
一些心得体会
算法学习中，有些可以半懂不懂，比如 kmp，了解 \(fail\) 是啥，怎么写代码就行了，这样反而会更轻松。而有些若想要融汇贯通，则必须充分理解，才能应用到题目中。
写博客总结的过程中，可以顺便梳理整个过程。带着想要教会别人的目标，不知不觉间自己也能更加深刻地理解。更何况，认真写出一篇博客后，成就感是真真切切的。
前路漫漫，未到抬头之时，我只需，低头前行。
