AC自动机学习小记

算法简介

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

必备技能

KMP 算法， Trie （字典树）。

算法分析

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

算法步骤

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

具体细节见代码实现。

代码实现

注：以下代码对应题目HDU2222 Keywords Search。是一道 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封装的 AC 自动机代码十分优美。
有些题目可能需要时间换空间，就是用模拟链表代替上面的 26 个数的数组连边，具体实现大家自行脑补。

时间复杂度

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