AC自动机学习小记

算法简介

$\mathrm{AC}$自动机，英文$\mathrm{Aho-Corasick\ automaton}$。1975年产生于贝尔实验室，是著名的多模式匹配算法之一。

---

必备技能

$\mathrm{KMP}$算法，$\mathrm{Trie}$（字典树）。

---

算法分析

$\mathrm{AC}$自动机其实就是将所有模式串放进一颗$\mathrm{Trie}$里，再进行$\mathrm{KMP}$算法。
学过$\mathrm{KMP}$算法的都知道，$\mathrm{KMP}$算法是借助失配函数${next}$将模式匹配的复杂度降到$\mathrm{O}(n+m)$，而$\mathrm{AC}$自动机也有失配指针${fail}$担任相似的任务。
在$\mathrm{KMP}$算法中，设模式串为$s$，${next_i}$满足$s_{1..next_i}=s_{i-next_i+1..i}$且最大。而$\mathrm{AC}$自动机中，$fail_i$满足$\mathrm{Trie}$中从根节点到$fail_i$组成的字符串是从根节点到$i$组成的字符串的后缀，且深度最大。

---

算法步骤

1. 先将所有模式串存进$\mathrm{Trie}$里面，注意在每个模式串结尾的结点做标记。
   • 用一次$\mathrm{BFS}$处理出$\mathrm{Trie}$上所有节点的$fail$指针。
   • 将匹配串在$\mathrm{Trie}$中进行匹配，走得了就走，走不了就不停往$fail_i$跳，直到能继续走或是到达$root$（我的实现方法直接将原本没有的儿子赋值为第一个能走的位置，这样写更加优美）。确定当前位置后，用$temp$指针从当前匹配位置开始，不停往$fail_{temp}$跳，直到到达$root$。$temp$在移动过程中，不停统计答案，并根据题目需要修改节点的权值（如果不允许重复计数，那就将该节点权值清$0$）。这样做是为了避免遗漏单词。

具体细节见代码实现。

---

代码实现

注：以下代码对应题目HDU2222 Keywords Search。是一道$\mathrm{AC}$自动机模板题，大家可以去练一下。
题目大意
给出若种模式串和一个匹配串，求匹配串中出现了多少种模式串。

#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>

using namespace std;

const int N=10005;
const int S=1000000;
const int L=26;

char rdstr[S+1];
int n,ans,cas;
queue<int> Q;

struct AC_automation
{
    int fail[N*50+1],sum[N*50+1],next[N*50+1][L];
    int tot,root;

    int newnode()
    {
        for (int i=0;i<L;i++)
            next[tot][i]=-1;
        fail[tot]=sum[tot]=0;
        return tot++;
    }

    int init()
    {
        tot=0;
        root=newnode();
    }

    void insert(char str[])
    {
        int rt=root,len=strlen(str);
        for (int i=0;i<len;i++)
        {
            if (next[rt][str[i]-'a']==-1)
                next[rt][str[i]-'a']=newnode();
            rt=next[rt][str[i]-'a'];
        }
        sum[rt]++;
    }

    void build()
    {
        fail[root]=root;
        for (int i=0;i<L;i++)
            if (next[root][i]==-1)
                next[root][i]=root;
            else
            {
                fail[next[root][i]]=root;
                Q.push(next[root][i]);
            }
        while (!Q.empty())
        {
            int x=Q.front();
            Q.pop();
            for (int i=0;i<L;i++)
                if (next[x][i]==-1)
                    next[x][i]=next[fail[x]][i];
                else
                {
                    fail[next[x][i]]=next[fail[x]][i];
                    Q.push(next[x][i]);
                }
        }
    }

    int query(char str[])
    {
        int rt=root,len=strlen(str),tmp,ret=0;
        for (int i=0;i<len;i++)
        {
            rt=next[rt][str[i]-'a'];
            tmp=rt;
            while (tmp!=root)
            {
                ret+=sum[tmp];
                sum[tmp]=0;
                tmp=fail[tmp];
            }
        }
        return ret;
    }
}acam;

int read()
{
    int x=0,f=1;
    char ch=getchar();
    while (ch<'0'||ch>'9')
    {
        if (ch=='-')
            f=-1;
        ch=getchar();
    }
    while (ch>='0'&&ch<='9')
    {
        x=x*10+ch-'0';
        ch=getchar();
    }
    return x*f;
}

int main()
{
    freopen("keyword.in","r",stdin);
    freopen("keyword.out","w",stdout);
    cas=read();
    while (cas)
    {
        n=read();
        acam.init();
        for (int i=1;i<=n;i++)
        {
            scanf("%s",rdstr);
            acam.insert(rdstr);
        }
        acam.build();
        scanf("%s",rdstr);
        ans=acam.query(rdstr);
        printf("%d\n",ans);
        cas--;
    }
    fclose(stdin);
    fclose(stdout);
    return 0;
}

经过struct封装的$\mathrm{AC}$自动机代码十分优美。
有些题目可能需要时间换空间，就是用模拟链表代替上面的$26$个数的数组连边，具体实现大家自行脑补。

---

时间复杂度

设匹配串长度为$n$，模式串共$m$个，第$i$个记为$s_i$。
可以证明$\mathrm{AC}$自动机时间复杂度为$\mathrm O(n+\sum_{i=1}^{m} length(s_i))$。
具体证明我也不会QAQ。感性理解吧！
证明方法应该和$\mathrm{KMP}$算法的时间复杂度证明相似。分析每个变量运算次数，下去自行脑补吧。