算法学习笔记(20): AC自动机

AC自动机

前置知识：

目录

使用场景

AC自动机是一种著名的多模式匹配算法。

可以完成类似于KMP算法的工作，但是由单字符串的匹配变成了多字符串的匹配。

一般来说，会有很多子串，和一个母串。问题常是求字串在母串中的出现情况（包括位置，次数，等等）

算法思想与流程

我在Trie树一文中提到过这样一句话

而AC自动机的核心就在于通过对Trie树进行处理，使得在处理母串的信息时可以快速的进行状态转移。

可以类比KMP的算法流程，但是这不重要

例如子串有 aa, ab, abc, b。母串为 ababcba。

由于我们是通过母串进行状态转移，所以需要先把所有字串的信息搞定

我们可以先处理子串，建一棵Trie树

明显，对于一个字串的匹配，是不可能在树上一路到底的，所以要构建匹配失败时的回退机制。也就是需要构建失配指针。

那么失配指针是干什么的？也就是用来在 Trie 树上向上跳，找到可以转移的一个节点，进行状态转移。

假如我现在在3号节点，并且我下一个需要转移的状态是 b，很明显，我此时应该回退到1节点（其上第一个可以通过 b 转移的节点）并转移到4节点。如果再来一个 b，也只能向上走到0号节点，然后转移到2号节点。

如此看来，我们完全可以暴力向上跳找到可转移的状态或者到达根为止。但是，这明显不够优秀，我们完全可以继承其子节点的。也就是继承 fail 的子节点。使得不需要暴力向上跳。

那说了半天，fail 到底指向啥？

假设父节点到当前节点转移的状态为 x，父节点之上第一个可以通过 x 转移到下一个节点的节点为 u，则 fail 指向 u 通过 x 转移过后的节点。

其实还有另一种解释的方法

fail 指向 p 代表当前串的最长已知后缀。

例如 aa 的最长已知后缀为 a，所以 3号节点的 fail 指向 1号节点；abc 的最长已知后缀为空，所以 5 号节点的 fail 指向根节点。

好混乱，我尽力了……

那么核心代码……就是利用 BFS 来处理

void procFail(int * q) {
    int head(0), tail(0);
    for (int i(0); i < 26; ++i) {
        if (kids[0][i]) q[tail++] = kids[0][i];
    }

    while (head ^ tail) {
        int x = q[head++];
        for (int i(0); i < 26; ++i) {
            if (kids[x][i]) {
                fail[kids[x][i]] = kids[fail[x]][i];
                q[tail++] = kids[x][i];
            } else kids[x][i] = kids[fail[x]][i];
        }
    } // procFail end
}

注意事项：一般来说，把 0 号作为根节点会比较方便。反正 0 上不可能有信息保存。

插入部分我就不需要讲了

匹配的判断

如何判断当前状态有没有匹配任何一个字串，只需要不断向上跳 fail，看跳到的节点是不是代表着字串。

拿模板：【模板】AC 自动机（简单版） - 洛谷 为例。

插入的时候在最后标记一下有没有匹配：

void insert(string &s) {
    int p(0);
    for (int c : s) {
        if (!kids[p][(c -= 'a')]) kids[p][c] = ++usage;
        p = kids[p][c];
    }
    ++cnt[p];
}

在匹配的时候暴力跳就是了：

int ACMatch(string & s) {
    int p(0), ans(0);
    for (int c : s) {
        p = kids[p][(c -= 'a')];
        for (int t(p); t && ~cnt[t]; t = fail[t]) {
            ans += cnt[t], cnt[t] = -1;
        }
    }
    return ans;
}

由于每一个串只能匹配一次，所以这里采用的清空的策略。并且标记清空，以免重复搜索。

失配树的应用

就拿模板题来说吧：【模板】AC 自动机（二次加强版） - 洛谷

他是要求所有字串的出现情况。

那么，我们先把每一个到达的状态计数。再通过 fail 指针向上跳求和。

但毕竟不能每一个节点都暴力跳，所以考虑在 fail 树上求和。

但是，我们不是有一个 q 来 BFS 吗？其中的 fail 是有序的：对于一个节点 x，其 fail 一定在 x 之前被遍历到。

所以我们直接使用 q 即可。

那么合起来大概也就是这样：

inline void ACMatch(string &s) {
    int p(0);
    for (char c : s) {
        p = kids[p][c - 'a'];
        ++cnt[p];
    }
}

inline void ACCount(int * q) {
    for (int i = usage; i; --i) {
        cnt[fail[q[i]]] += cnt[q[i]];
    }
}

但是每一个特定的字串出现的次数呢？

在插入时记住字串对应的节点，输出即可。

void insert(string &s, int i) {
    int p(0);
    for (int c : s) {
        if (!kids[p][(c -= 'a')]) kids[p][c] = newNode();
        p = kids[p][c];
    }
    pos[i] = p;
}


inline void ACOutput(int n) {
    for (int i = 1; i <= n; ++i) {
        cout << cnt[pos[i]] << '\n';
    }
}

有这么一道题：

很明显，对于每一个位置，我们需要清理能匹配到的最长长度，所以我们需要预处理出最长长度：

inline void ACprepare(int * q) {
    for (int i = 1; i <= usage; ++i) {
        len[q[i]] = max(len[q[i]], len[fail[q[i]]]);
    }
}

在清理时：

inline void ACclean(string &s) {
    int p(0);
    for (unsigned i(0), ie = s.size(); i < ie; ++i) {
        p = kids[p][discrete(s[i])];
        if (len[p]) for (unsigned j = i - len[p] + 1; j <= i; ++j)
            s[j] = '*';
    }
}

由于是引用的字符串，所以可以直接修改。

对状态的理解

在我们考试的时候有这么一道题：

这道题说难也难，说不难也不难。主要是看对于 AC自动机 状态转移的理解到不到位。

在匹配过程中，如果匹配到了出现的 w，那么就要回到 len(w) 个状态前，继续匹配下一个字符。

很明显，需要用栈，并且由于需要一次弹出多个，所以最好用手写的栈。

核心代码如下：

string sub, pat;
cin >> sub >> pat;
insert(sub), procFail(Q);

int p = 0;
for (int i(0), ie = pat.size(); i < ie; ++i) {
    p = kids[cps[ci]][pat[i] - 'a'];
    cps[++ci] = p, ccs[ci] = pat[i];
    if (match[p]) ci -= sub.size();
}

for (int i = 1; i <= ci; ++i) {
    putchar(ccs[i]);
}

这里没有用到 fail，那么为什么还要构建失配树？

这是个好问题，因为，构建失配树的过程不仅仅构建了失配树，同时还令节点继承了其 fail 的子节点，所以需要构建的过程。

这道题其实完全可以用 KMP 做，但是显然的，用 AC 自动机做可以做到多匹配串的删除，其实也就变成了上一题和本题的融合，这是 KMP 无法完成的。

最后附上模板题【模板】AC 自动机（二次加强版） - 洛谷的代码：云剪贴板 - 洛谷

原树与失配树

在串 \(S\) 与 \(T\) 匹配的时候，一般会有两个问题：出现没有？出现了多少次？

而这两个问题换一换主语又可以产生新的问题，谁在谁中出现？

假定 \(S\) 为给定的一些串构成的序列：

  • 多次查某个 \(T\) 在其中某个区间有多少包含它（不重复计算）。

  • 多次查某个 \(T\) 在其中某个区间出现的次数。

  • 多次查某个 \(T\) 在其中某个区间它包含了哪些（不重复计算）。

  • 多次查某个 \(T\) 在其中某个区间出现的在它中的次数。

好吧，自然而然的转化为差分，也就是 \(T\) 在 \(S\) 的 \([1, r]\) 中的出现情况。

对于第一问，考虑 \(T\) 在什么时候被包含，也就是存在某个 \(S\) 的某个节点的 \(fail\) 可以跳到它。

自然的，想到在原树上将 \(S\) 一个一个加进去（在失配树上单点加），最终在失配树上求一个子树和。这容易利用树状数组维护。

但是发现这其实是第二问的答案，考虑如何不重复的计算。

此时考虑一个差分，将加入的结点按照 dfs 序排序，然后在两两 LCA 处 -1 即可做到全不重不漏覆盖。

至于正确性可以考虑虚树，此处不展开。

那么对于后面两个问题，\(T\) 包含的也就是其原树上通过失配树可以跳到的一些点。

发现一个串对它有贡献，那么这个串的末尾一定是 \(T\) 某点在失配树上的祖先，那么此时查询 \(T\) 原树路径点在失配树到根的贡献和即可。这也容易利用树状数组维护。

如果是不重复的，也可以小小的考虑一个差分，与上面同理。

但是注意到这个复杂度是 \(O(|T|)\) 的，在多次询问的时候非常不友好。

但是一般来说，存在 \(\sum |T| \le L\) 的限制（不然连读入都困难），所以此时可以小小的考虑根号分治的做法。

对于长度 \(\le \sqrt L\) 的串，完全可以暴力扫，对于长度 \(\gt \sqrt L\) 的串，它最多只有 \(\sqrt L\) 个，所以完全支持 \(O(\sum |S|)\) 的预处理它，也就是将每一个所有串重新插入 AC 自动机中，然后利用失配树 \(O(|T|)\) 的做一次求出每一个串对它的贡献，那么最后维护一下区间和即可。

这其实就是 【模板】AC 自动机（二次加强版） - 洛谷。

如果是不重复的话，也就是 【模板】AC 自动机（简单版） - 洛谷。

在自动机上 DP

一般来说，有两种 \(f_{i, j}\) 状态。第一种表示节点 - 个数，第二种表示串 - 匹配位置。

注意两者适用情况不太一样。第二种隐含了节点的信息，但是在个数（类背包）的处理上就无能为力。第一种则是无法很好的区分到底谁是谁。用什么依情况考虑。

  • 给定若干串 \(S_i\)，构造一个长度为 \(k\) 的串，使得给定的串在其中出现的次数最多。

建出 trie 图并预处理 fail 树上祖先和。利用第一种状态，转移是简单的。当串长很小，但是 \(k\) 很大的时候，可以利用矩阵快速幂。

  • 定义 \(M(s, t)\) 表示 \(t\) 在 \(s\) 中出现的次数，求 \(\sum_i \sum_j \sum_k \sum_x \sum_y \sum_z M(S_i + S_j + S_k, S_x + S_y + S_z)\)。

巨抽象题，利用第二种状态，但是需要 \(f_\)

一些小套路

对于多次询问，\(\sum |S| \le L\)，然而看到总长小于定值，你会想到？

  • 本质不同的长度至多只有 \(O(\sqrt L)\) 个。

那么这自然而然的带来的就是根号分治。

对于一些稍微难一点的东西，很可能会用到这个性质，但是我声称其仁者见仁智者见智。或许根本也不会遇到……

单个串的时候其实完全可以使用 KMP，并且你会发现 KMP 在单串可扩展性更强，因为其不依赖于字符集的大小，也就是说可以扩展到实数集，而不是单纯的字符，这是 AC 自动机所不能拥有的优势。

但是并不意味这 AC 自动机就无法做到扩展字符集的行为。如果能够支持 \(O(\log n)\) 的代价，那么完全可以利用 map 之类的结构维护其子节点。

这基于失配树是一颗树的性质，也就是失配指针只会指向一个，这与 KMP 是相似的。

但是在预处理时需要注意，不存在的节点不能指向失配点的子节点，否则时空复杂度都是不正确的。在使用的时候判断一下即可。

posted @ 2023-03-26 14:14  jeefy  阅读(182)  评论(0)  编辑  收藏  举报