AC自动机详解

上次更新

[2017.12.21]AT CDQZ 十二月中旬联训。

前言

刚刚写完了一篇关于KMP的一篇博客，在那里我就说，强烈建议同学们“进修”一下“AC自动机”。而现在我又要说：如果你对KMP算法还没有一个深入的理解，先不要急着学“AC自动机”，因为它的思想是完全基于KMP算法上的。所以给各位同学一个友情链接，看完它再进行AC自动机的学习。

友情链接1：神奇的KMP——线性时间匹配算法（初学者请进）

友情链接2：Trie 前缀树/字典树/单词查找树（数据结构）

（小时候一直天真地觉得：“哇！竟然有这么强的一种数据结构，竟然能自动AC。”后来才知道“AC自动机”其实是“Aho-Corasick自动机”的简称。并不是说用了就可以“AC”的意思。）

1.AC自动机的实现功能与原理

在360百科中对AC自动机的用途以及原理给出了这样的解释：

（AC自动机的）一个常见的例子就是给出n个单词，再给出一段包含m个字符的文章，让你找出有多少个单词在文章里出现过。

要搞懂AC自动机，先得有模式树(字典树)Trie和KMP模式匹配算法的基础知识。 AC自动机算法分为3步:构造一棵Trie树，构造失败指针和模式匹配过程。

如果你对KMP算法了解的话，应该知道KMP算法中的next函数(shift函数或者fail函数)是干什么用的。KMP中我们用两个指针i和j分别表示，A[i-j+ 1..i]与B[1..j]完全相等。也就是说，i是不断增加的，随着i的增加j相应地变化，且j满足以A[i]结尾的长度为j的字符串正好匹配B串的前 j个字符，当A[i+1]≠B[j+1]，KMP的策略是调整j的位置(减小j值)使得A[i-j+1..i]与B[1..j]保持匹配且新的B[j+1]恰好与A[i+1]匹配，而next函数恰恰记录了这个j应该调整到的位置。同样AC自动机的失败指针具有同样的功能，也就是说当我们的模式串在Trie上进行匹配时，如果与当前节点的关键字不能继续匹配，就应该去当前节点的失败指针所指向的节点继续进行匹配。

请忽略掉上文中没有加粗的内容。

（一是因为它说得太笼统，而是因为它对变量的定义与使用与我的是不一样的，容易误导读者。）

KMP算法只能用于单个模式串的字符串匹配（我们在字符串T中寻找字符串P的出现位置，T叫做文本串，P叫做模式串），如果我要是想在同一个文本串中给n个模式串进行匹配，那我就得跑n遍KMP，这样做是非常浪费时间的（尽管KMP是线性时间算法）。我们能不能找到一种方法，只在文本串中走一遍就能对所有模式串进行匹配呢？这就是AC自动机。

2.AC自动机与Tire树和KMP之间的关系

AC自动机的原理与KMP是完全相同的，就是当我出现了一次“失配”后并不是从整个模式串的开头重新匹配，而是找到一个位置，把它变为“当前节点”继续匹配。就比如说我在一个T=”…misl…”（“…”表示省略部分）的文本串中匹配模式串P[0]=”miss”和P[1]=”island”。我先匹配出“mis”然后失配，如果这是我们能把它用“失配边”（用来描述一个结点失配之后的状态转移）实现，把它转移到“island”的配对，那真是极好的！



（非常不好理解的地方来了：）

也就是说对于Trie中的每一个结点所表示的一个模式串前缀我们都要找到它最长的（不为它本身的）一个后缀，满足是整个Trie的一个前缀。然后这个整个Trie的一个前缀的末尾结点就是当前失配边所指向的结点。这可以用BFS的方法遍历这棵树，递推求得。最后的得到带有“失配边”的一个Trie树（我叫它“AC-Trie”）。

比如说，原来的Trie树是这样的（圈中数字代表权值，空白代表为0）：



处理之后就会变成这样（中括号中的数字代表结点的编号）：



另外，AC自动机的结果输出功能是不同于KMP的。就比如说如果P[i]=”his”得到了成功匹配，其实这个时候

P[j]=”is”也得到了成功匹配（因为P[j]是P[i]的后缀）。所以，我们在输出结果的那时候一定要考虑到这种情况。

分析这样一个问题：P[j]的成功匹配输出与f[J]的失配函数是否有着某种联系。f[j]表示的是线段树中最长的一个前缀为P[j]的一个后缀，如果f[j]恰好为我的一个模式串，这时候f[j]也需要输出。如果f[f[j]]恰为一个模式串，而f[f[j]]是f[j]串的一个后缀，如果f[j]满足那么f[f[j]]自然也需要输出。我们可以用一个叫last的数组储存，如果一个模式串成功地匹配，那么他的最长的 满足为整个trie树的一个前缀的 一个后缀的结点号。在正规的文献中这个“last”数组被称为“后缀链接”（suffix link）。

3.AC自动机的实现

有了之前的这些理论，我们可以尝试着编写一下它的源代码（讲解我都写到代码注释里面去了）。

关于Trie树部分的注释参见友情链接：

友情链接：Trie 前缀树/字典树/单词查找树（数据结构）

样例代码：

int idx(char c) //用于返回一个字符的索引值
{
return c-'a';
}
struct AC_Trie
{
int next[MaxNode][26];//所有子结点
int val[MaxNode];//结点的权值
int size;//结点总数
AC_Trie()//构造函数
{
size=0;
memset(next[0],0,sizeof(next[0]));
}
void insert(char* str,int Value)//插入一个字符串
{//详见Trie树解析
int nodeNow=0,n=strlen(str);
for(int i=0;i<n;i++)
{
int charNow=idx(str[i]);
if(next[nodeNow][charNow]==0)
{
next[nodeNow][charNow]=++size;
memset(next[size],0,sizeof(next[size]));
val[size]=0;
}
nodeNow=next[nodeNow][charNow];
}
val[nodeNow]=Value;
}
int Search(char* str)//查询一个字符串是否出现过
{//同上,详见Trie树解析
int nodeNow=0,n=strlen(str);
for(int i=0;i<n;i++)
{
int charNow=idx(str[i]);
if(next[nodeNow][charNow]==0)
return 0;
nodeNow=next[nodeNow][charNow];
}
return val[nodeNow];
}
int f[MaxNode];//失配函数
int last[MaxNode];
//last[i]表示如果结点j所代表的的模式串满足匹配
//那么last[i]所表示的模式串也需要输出
void print(int j)
{
if(j!=0)
{
printf("%d:%d\n",j,val[j]);
print(last[j]);//递归输出last[j]
}
}//该print函数并不是很完备，完备的请同学们自己脑补一下吧
int getFail()//BFS计算失配边
{
queue<int>q;
f[0]=0;//规定f[0]=0;
for(int c=0;c<26;c++)//因为与0号结点相邻的结点前面只有0号结点一个结点
{//所以f[零号结点的儿子]=0
int nodeNow=next[0][c];
if(nodeNow!=0)//如果这个儿子存在,接把他的失配边赋成0
{
f[nodeNow]=0;
q.push(nodeNow);//顺道把这个儿子结点放入BFS队列中
last[nodeNow]=0;
}
}
while(q.empty()!=0)//BFS队列非空
{
int r=q.front();q.pop();//BFS队列中弹出一个结点
for(int c=0;c<26;c++)//对于这个节点的所有儿子
{
int nodeNow=next[r][c];
if(nodeNow==0)
continue;
q.push(nodeNow);//当前结点入队入队
int v=f[r];
while(v!=0 && next[v][c]==0)
v=f[v];//一直在失配边上跑,直到找到一个以'c'代表的字符为结尾的一个Trie的前缀
f[nodeNow]=next[v][c];//当前结点的失配边就连同到它身上
last[nodeNow]=val[f[nodeNow]]?f[nodeNow]:last[f[nodeNow]];
//如果失配边连着的位置恰好是一个模式串的结尾,那么他的last就是他的f
//否则他的last就是“他的f的f”
}
}
}
};

4.后记

写完AC自动机这篇之后，我还想学一学关于后缀数组的一些东西。

（温馨提示：我的代码是现写的，图片是现画的，所以不建议直接复制，可能会存在无数的漏洞。）

友情链接：Goseqh同学的AC自动机详解

他的代码比较完备，有需要的同学可以去看一看。

希望这篇文章能够加对各位同学有所帮助。赶稿匆忙，如有谬误，望各位同学谅解。

[2017.12.21]终于自己写出了AC自动机，开心，但是还没评测..

[2017.12.22]此代码有严重bug，请不要使用！

Luogu P3796 【模板】AC自动机（加强版）

#include<cstdio>
#include<queue>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;

const int maxn=1000000+10;
struct ACAM{
int nxt[maxn][27],val[maxn],fail[maxn],last[maxn],cnt[170];
int ncnt;
void init(){
ncnt=0;//start node is 0
memset(cnt,0,sizeof(cnt));
}
ACAM(){init();}
void addstr(const char* s,int v){
int now=0;//start node
for(int i=0;s[i];i++){
int idx=s[i]-'a'+1;
if(nxt[now][idx]==0){
nxt[now][idx]=++ncnt;//new node
memset(nxt[ncnt],0,sizeof(nxt[ncnt]));
val[ncnt]=0;
}
now=nxt[now][idx];
}
val[now]=v;//set value
}
void print(int u){
if(u!=0){
print(last[u]);
//printf(" %3d. ",val[u]);
cnt[val[u]]++;
}
}
void getFail(){
//printf("\n getFail. \n\n");
queue<int>Q;
for(int i=1;i<=25;i++){
int u=nxt[0][i];
if(u!=0){
fail[u]=0;
Q.push(u);
}
}
//printf("\n step 2. \n\n");
while(!Q.empty()){
int x=Q.front();Q.pop();
//printf("\n  x = %d. \n\n",x);
for(int i=1;i<=25;i++){
int u=nxt[x][i];
//printf("\n  u = %d. \n\n",u);
if(u!=0){
int j=fail[x];
while(j!=0 && nxt[j][i]==0)
j=fail[j];
fail[u]=nxt[j][i];
last[u]=val[fail[u]]?fail[u]:last[fail[u]];
Q.push(u);
}
}
}
}
void match(const char* s){
int now=0;
for(int i=0;s[i];i++){
//printf(" i = %d. \n",i);
int idx=s[i]-'a'+1;
while(now!=0 && nxt[now][idx]==0)
now=fail[now];
now=nxt[now][idx];
if(val[now]){
/*printf("find at %6d. : ",i);*/print(now);
//putchar('\n');
}else if(last[now]){
/*printf("find at %6d. : ",i);*/print(last[now]);
//putchar('\n');
}
}
}
}acam;

char s[maxn],tmp[maxn];

int debug_main(){
for(;;){
int op;scanf("%d",&op);
if(op==1){
scanf("%s",tmp);scanf("%d",&op);
if(op==0){
printf("\n error = \"value leq 0\". \n\n");
system("pause>nul");
}else{
acam.addstr(tmp,op);
printf("\n OK. \n\n");
}
}else if(op==2){
acam.getFail();
printf("\n OK. \n\n");
}else if(op==3){
scanf("%s",s);
acam.match(s);
printf("\n ans = \"solve end\". \n\n");
}else{
printf("\n error = \"unknown instruction\". \n\n");
system("pause>nul");
}
}
return 0;
}

char tp[150+2][80];

int main(){
int N;
while(scanf("%d",&N) && N){
acam.init();
for(int i=1;i<=N;i++){
scanf("%s",tp[i]);
acam.addstr(tp[i],i);
}
acam.getFail();
scanf("%s",s);
acam.match(s);
int ans=0;
for(int i=1;i<=N;i++){
ans=max(ans,acam.cnt[i]);
}
printf("%d\n",ans);
for(int i=1;i<=N;i++){
if(acam.cnt[i]==ans){
printf("%s\n",tp[i]);
}
}
}
return 0;
}