【算法笔记】Aho-Corasick 算法（AC自动机）小结

最新推荐文章于 2024-02-24 14:24:31 发布

原创最新推荐文章于 2024-02-24 14:24:31 发布 · 686 阅读

2 ·

CC 4.0 BY-SA版权

ACM.数据结构同时被 2 个专栏收录

47 篇文章

订阅专栏

ACM.字符串

6 篇文章

订阅专栏

本文介绍AC自动机的优化技巧，包括压缩冗余转移、使用last指针提高效率及构造不含模式串的方法。通过具体代码示例展示了如何实现这些优化，并提供了POJ2778题目的解题思路。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

参考：

《算法竞赛入门经典-训练指南》
http://codeforces.com/blog/entry/14854
kuang bin blog

加上不存在的边，并压缩冗余转移

这个改进《训练指南》中说过，本文的目的是总结并实现一个自用的模板。。
AC自动机每个节点有一个 fail 指针，作用与KMP中相同。

假如我们的节点是这样的

// link 就是 fail 指针
const int MaxNode = 500000 + 50;
    const int CharSet = 26;
    int go[MaxNode][CharSet], link[MaxNode];
    int val[MaxNode]; // 附加信息，例如判断是否为一个单词的结尾
    int nodes;

在AC自动机中输入一个新的字符c，转移时会先沿着link指针走，遇到 go[c] not equal 0 的节点或者到了根就会停下。
中间走的这一段都不存在c转移，在构造的时候已经知道这个事实了，所以可以把这一段多跑的路给压缩掉。
把原来不存在的转移都补上
就再也没有while了～～

    void build() {
        queue<int> q;
        q.push(0);
        while ( !q.empty() ) {
            int u = q.front(); q.pop();
            int fa = link[u];
            for (int i = 0; i < CharSet; ++i) {
                int v = go[u][i];
                if ( v ) {
                    link[v] = u ? go[fa][i] : 0;
                    q.push(v);
                } else {
                    go[u][i] = go[fa][i];
                }
            }
        }
    }

    init();
    ac_insert("hers");
    ac_insert("she");
    ac_insert("he");
    ac_insert("s");
    get_draw(root, "");
    ac_construct();
    match("she");
    return 0;

改进后fail指针的指向
这里写图片描述

一开始写的是指针形式的，也是预先分配内存

struct Node {
    Node *go[CharSet], *link;
    int count;
};

不过指针的开销貌似会更大？虽然看起来是一样的。。
hdu 2222 一直 MLE
所以实际的板子改成了开数组的

用last指针进一步提高转移效率

用last指针表示沿着link走，遇到的第一个为某个单词结尾的节点。
这样在match的时候，沿着 last 走而不是 link，遇到的都是单词节点

    void build() {
        queue<int> q;
        q.push(0);
        while ( !q.empty() ) {
            int u = q.front(); q.pop();
            int fa = link[u];
            for (int i = 0; i < CharSet; ++i) {
                int v = go[u][i];
                if ( v ) {
                    link[v] = u ? go[fa][i] : 0;
                    last[v] = val[link[v]] ? link[v] : last[link[v]];
                    q.push(v);
                } else {
                    go[u][i] = go[fa][i];
                }
            }
        }
    }

我的模板

namespace Trie {
    const int MaxNode = 500000 + 50;
    const int CharSet = 26;
    int go[MaxNode][CharSet], link[MaxNode], last[MaxNode];
    int val[MaxNode];
    int nodes;

    void init() {
        nodes = 1;
        memset(go[0], 0, sizeof(go[0]));
    }

    int allocate() {
        memset(go[nodes], 0, sizeof(go[nodes]));
        val[nodes] = 0;
        last[nodes] = 0;
        link[nodes ++] = 0;
        return nodes - 1;
    }

    void add( const char* s ) {
        int cur = 0;
        for (; *s; ++ s) {
            int id = *s - 'a';
            if ( !go[cur][id] ) {
                go[cur][id] = allocate();
            }
            cur = go[cur][id];
        }
        val[cur] += 1;
    }

    int match(const char* s) {
        int cur = 0, ret = 0;
        for (; *s; ++s) {
            cur = go[cur][*s-'a'];
            int tmp = cur;
            if ( val[tmp] ) {
                ret += val[tmp], val[tmp] = 0;
            }
            while ( last[tmp] ) {
                tmp = last[tmp];
                if ( val[tmp] ) {
                    ret += val[tmp], val[tmp] = 0;
                }
            }
        }
        return ret;
    }

    void build() {
        queue<int> q;
        q.push(0);
        while ( !q.empty() ) {
            int u = q.front(); q.pop();
            int fa = link[u];
            for (int i = 0; i < CharSet; ++i) {
                int v = go[u][i];
                if ( v ) {
                    link[v] = u ? go[fa][i] : 0;
                    last[v] = val[link[v]] ? link[v] : last[link[v]];
                    q.push(v);
                } else {
                    go[u][i] = go[fa][i];
                }
            }
        }
    }
}

构造不包含模式的串

当自动机构造好后，我们有了 r 个状态。那么就存在一个 r x r的矩阵 T，T(i，j) 表示状态 i 转移到状态 j 的方法数
T 可以这样构造

// 输入 (当前状态，输入) 
// 返回转移到的状态， -1 表示无效转移
int check(int st, int input) {
        st= go[st][input];
        // 如果当前节点或其后缀是模式串，则为无效转移
        if ( tag[st] || last[st] ) return -1;
        return st;
}

Mat T(r); // r 为状态总数
memset(T.m, 0, sizeof(T.m));
for (int i = 0; i < n; ++i) {
    for (int j = 0; j < CharSet; ++j) {
        int st = check(i, j);
        if ( st != -1 ) T.m[i][st] += 1;
    }
}