浅谈AC自动机算法（c++）

自动机

自动机是什么？
自动机的作用一般是识别字符串。一个自动机 A ，若它能识别（接受）字符串 S ，那
么 A(S) = True ，否则 A(S) = False 。
当一个自动机读入一个字符串时，从初始状态（根节点）起按照转移函数一个一个字符
地转移。如果读入完一个字符串的所有字符后位于一个接受状态，那么我们称这个自动
机 接受 这个字符串，反之我们称这个自动机 不接受 这个字符串。

一些简单的自动机：

Trie 树。其转移函数就是针对每个节点的儿子集合。其能接受的字符串就是插入到Trie 树中的字符串（或者是插入到 Trie 树中的字符串的前缀，这取决于你如何定义Trie 树的接受状态）。
子序列自动机。其能接受的字符串是给定字符串的所有子序列。其转移函数 trans(x, c) 是在字符 c 对应的 vector 里 upper_bound x得到的返回值。每个节点都可以看作接受状态。
KMP 自动机。由 s 构造的自动机能接受的字符串是以 s 为子串的串 t。其转移函数trans(x, c) 是不断跳 x 的 next 指针直到满足 sx+1 = c。可以认为匹配完 s 的状态是终止状态。

AC 自动机

AC 自动机的全称是 Aho-Corasick Automation。
我真希望是ACCEPT
其中 Aho-Corasick 是人名 Alfred Aho 和 Margaret Corasick。
接受且仅接受以指定的字符串集合中的某个元素为子串的字符串。
AC 自动机是 以 Trie 的结构为基础 ，结合 KMP 的思想 建立的。
简单来说，建立一个 AC 自动机有两个步骤：

1. 基础的 Trie 结构：将所有的模式串构成一棵 Trie。
2. KMP 的思想：对 Trie 树上所有的结点构造失配指针。
   然后就可以利用它进行多模式匹配了。

字典树构建

AC 自动机在初始时会将若干个模式串丢到一个 Trie 里，然后在 Trie 上建立 AC 自动机。
这个 Trie 就是普通的 Trie，该怎么建怎么建。
这里需要仔细解释一下 Trie 的结点的含义，尽管这很小儿科，但在之后的理解中极其重要。Trie 中的结点表示的是某个模式串的前缀。我们在后文也将其称作状态。一个结点表示一个状态，Trie 的边就是状态的转移。
形式化地说，对于若干个模式串 ，将它们构建一棵字典树后的所有状态的$s_1,s_2\dots s_n$集合记作 Q。

失配指针

AC 自动机利用一个 fail 指针来辅助多模式串的匹配。
状态 u 的 fail 指针指向另一个状态 v ，其中 v ∈ Q ，且 v 是 u 的最长后缀（即在若干
个后缀状态中取最长的一个作为 fail 指针）。这里简单对比一下这里的 fail 指针与 KMP
中的 next 指针：

1. 共同点：两者同样是在失配的时候用于跳转的指针。
2. 不同点：next 指针求的是最长 Border（即最长的相同前后缀），而 fail 指针指向所
   有模式串的前缀中匹配当前状态的最长后缀。
   因为 KMP 只对一个模式串做匹配，而 AC 自动机要对多个模式串做匹配。有可能 fail 指针指向的结点对应着另一个模式串，两者前缀不同。
   当 AC 自动机的搭建只对一个串进行时，AC 自动机的 fail 指针就是 KMP 的 next 指针。

构建指针

下面介绍构建 fail 指针的基础思想（也是 AC 自动机实现的第一种方式）：
构建 fail 指针，可以参考 KMP 中构造 Next 指针的思想。
考虑字典树中当前的结点u，u的父结点是u，u通过字符 c 的边指向u,即trie[p, c] = u。假设深度小于u 的所有结点的 fail 指针都已求得（只需要通过 BFS 就可以得到这个性质）（特别的，令 fail[root] = root，令深度为 1 的所有节点 x, fail[x] =root）。

1. 如果 trie[fail[p], c] 存在：则让 u 的 fail 指针指向 trie[fail[p], c] 。相当于在p和fail[p]后面加一个字符 c ，分别对应u 和 fail[u] 。
2. 如果fail[u]不存在：那么我们继续找到trie[fail[fail[p]], c] 。重复 1 的判断过程，一直跳 fail 指针直到根结点。
3. 如果真的没有，就让 fail 指针指向根结点。如此即完成了fail[u] 的构建。

[HNOI2006] 最短母串问题

题目描述

给定 $n$ 个字符串 $(S_1,S_2,...,S_n)$，要求找到一个最短的字符串 $T$，使得这 $n$ 个字符串 $(S_1,S_2,...,S_n)$ 都是 $T$ 的子串。

输入格式

输入文件第一行是一个整数 $n$，表示给定的字符串个数。接下来 $n$ 行，每行有一个全由大写字母组成的字符串，。

输出格式

输出文件只有一行，为找到的最短的字符串 $T$。在保证最短的前提下，如果有多个字符串都满足要求，那么必须输出按字典序排列的第一个。

样例 #1

样例输入 #1

2
ABCD
BCDABC

样例输出 #1

ABCDABC

提示

对于 $100\%$ 的数据，$n\le 12$，每个字符串的长度不超过 $50$。

思路

对于一个特定的字符串 T，如何判断$S_1\dots S_n$中的哪些串在其中出现过？
与前一道题很类似的，我们对 S 建 AC 自动机。接着可以认为$fai{l}_x$，如果 中含有字符
串$S_i$ ，那么x中也含有字符串$S_i$。这样的话每个节点会含有${S_1 …S_n}的一个子
集。考虑到 n 很小，这个集合是可以状压的。
只需要把字符串 T 丢到 AC 自动机上跑，然后对经过的所有点的集合取并就好了。
既然说这个集合是可以状压的，实际上做法已经呼之欲出了：只需要在 AC 自动机上写
一个状压 DP 就好了。
实际上甚至不能说是状压 DP，因为通过 bfs 就可以实现这个功能。
具体来说就是 diss,i 表示在节点 i，已经包含的字符串集合为 s 的最短长度。
初始态是 dis0,root = 0，只要按照由小到大的顺序去枚举字符，得到的结果自然是最小
字典序的。

AC代码

#include<bits/stdc++.h>
using namespace std;
const int N=610;
int add[N][26],fail[N],state[N],nod,ans[N*(1<<12|1)],fa[N*(1<<12|1)],n,cnt,tot;
bool vis[N][1<<12|1];
char s[N],ch[51];
queue<int>q,q1,q2;
inline void getfail(){
    for(int i=0;i<26;++i)
        if(add[0][i])q.push(add[0][i]);
    while(!q.empty()){
        int x=q.front();
        q.pop();
        for(int i=0;i<26;++i)
            if(add[x][i]){
                fail[add[x][i]]=add[fail[x]][i];
                state[add[x][i]]|=state[add[fail[x]][i]];
                q.push(add[x][i]);
            }
            else add[x][i]=add[fail[x]][i];
    }
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;++i){
        scanf("%s",ch);
        int now=0,ln=strlen(ch);
        for(int j=0;j<ln;++j){
            if(!add[now][ch[j]-'A'])add[now][ch[j]-'A']=++cnt;
            now=add[now][ch[j]-'A'];
        }
        state[now]|=1<<(i-1);
    }
    getfail();
    q1.push(0);
    q2.push(0);
    vis[0][0]=1;
    int Ti=0;
    while(!q1.empty()){
        int now=q1.front(),st=q2.front();
        q1.pop();q2.pop();
        if(st==((1<<n)-1)){
            while(Ti){
                s[++nod]=ans[Ti];
                Ti=fa[Ti];
            }
            for(int i=nod;i>0;--i)putchar(s[i]+'A');
            return 0;
        }
        for(int i=0;i<26;++i){
            if(!vis[add[now][i]][st|state[add[now][i]]]){
                vis[add[now][i]][st|state[add[now][i]]]=1;
                q1.push(add[now][i]);
                q2.push(st|state[add[now][i]]);
                fa[++tot]=Ti;
                ans[tot]=i;
            }
        }
        ++Ti;
    }
    return 0;
}

「一本通 2.4 例 1」Keywords Search

AC代码

#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int T, n, tree[N][26], tail[N], cnt, fail[N];
string s;
void Insert() {
    int len = s.size(), now = 0;

    for (int i = 0; i < len; i++) {
        int x = s[i] - 'a';

        if (tree[now][x] == 0)
            tree[now][x] = ++cnt;

        now = tree[now][x];
    }

    tail[now]++;
}
void get_fail() {
    queue<int> q;

    for (int i = 0; i < 26; i++) {
        int x = tree[0][i];

        if (x) {
            fail[x] = 0;
            q.push(x);
        } else
            tree[0][i] = tree[fail[0]][i];
    }

    while (!q.empty()) {
        int t = q.front();
        q.pop();

        for (int i = 0; i < 26; i++) {
            int x = tree[t][i];

            if (x) {
                q.push(x);
                fail[x] = tree[fail[t]][i];
            } else
                tree[t][i] = tree[fail[t]][i];
        }
    }
}
int find() {
    int res = 0, now = 0, len = s.size();

    for (int i = 0; i < len; i++) {
        int x = s[i] - 'a';
        now = tree[now][x];

        for (int j = now; j && tail[j] != -1; j = fail[j]) {
            res += tail[j];
            tail[j] = -1;
        }
    }

    return res;
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> T;

    while (T--) {
        memset(tree, 0, sizeof(tree));
        memset(tail, 0, sizeof(tail));
        memset(fail, 0, sizeof(fail));
        cnt = 0;
        cin >> n;
        fail[0] = 0;

        while (n--) {
            cin >> s;
            Insert();
        }

        get_fail();
        cin >> s;
        cout << find() << endl;
    }

    return 0;
}

这是我的第二十一篇文章，如有纰漏也请各位大佬指正
辛苦创作不易，还望看官点赞收藏打赏，后续还会更新新的内容。