AC自动机详解及实现

最新推荐文章于 2024-06-18 12:51:06 发布
最新推荐文章于 2024-06-18 12:51:06 发布
阅读量2.5k 收藏 13
点赞数 7
分类专栏： NLP 自然语言处理 文章标签： AC自动机 数据结构 算法 字典树 后缀树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huoji555/article/details/105435014
版权
1.背景

之前的Trie树，DBTrie都属于前缀树，虽然DAT每次状态转移的时间复杂度都是常数，但全切分长度为n的文本时，时间复杂度为O(n2)。这是因为扫描过程中需要不断的挪动起点，发起新的查询。所以说，DAT的全切分复杂度为O(n2)。

2.为什么需要AC自动机

显然，前缀树的短板是扫描，查询一个句子时，前缀树需要不断的挪动起点，发起新查询，这个过程浪费了大量时间。

举个栗子，扫描"清华大学"这个短语，算法以"清"为起点扫描"清"，“清华”，“清华大”，“清华大学”，之后再回退到"华"，继续扫描"华"，“华大”…

如果能够在扫描到"清华大学"的同时想办法知道，“华大学”，“大学”，"学"在不在字典树中，那么就可以省略掉这三次查询，观察一下这三个字符串，它们共享递进式的后缀，首尾对调后(“学”,“学大”，“学大华”)恰好可以用另一颗前缀树索引，称它为后缀树。

AC(Aho-Corasick)自动机的原理就是在前缀树的基础上，为前缀树上的每个节点建立一颗后缀树，从而节省了大量查询。这使得每次扫描由原来的O(n2)降到了O(n)，AC自动机现在被广泛的用于多字符串匹配。


3.AC自动机的结构
  • success表：用于状态的成功转移，本质上是一个前缀树
  • output表：记录命中的模式串
  • failture表：保存状态间的一对一的关系，存储状态转移失败后应当回退的最佳状态，这里的最佳状态是指能记住已匹配上的字符串的最长后缀的那个状态。

4.AC自动机的构建过程

整体流程如下：

  • 添加模式串keyWord，构建树，根据seccess函数构建success表
  • 构建完成后，对树进行扫描，根据fail函数构建fail表
  • 外界输入文本，输出被命中的模式串

下面以图为例讲解，图来源于ProcessOn:
在这里插入图片描述


5.建立success表

sucess表的本质是前缀树，所以构建不再赘述，唯一不同的是，根节点不光可以按第一层的节点转移(比如像图中的h和s)，还可以接受其它字符，转移终点都是自己。下面是构建代码：

/**
 *  @author: Ragty
 *  @Date: 2020/4/1 14:22
 *  @Description: success跳转
 */
public Node find(Character character) {
    return map.get(character);
}


/**
 *  @author: Ragty
 *  @Date: 2020/4/1 14:23
 *  @Description: 状态转移(此处的transition为转移的状态，可理解为接收的一个词)
 */
private Node nextState(Character transition) {
    Node state = this.find(transition);             //先按success跳转

    if (state != null) {
        return state;
    }

    if (this.isRoot) {                              //如果跳转到根结点还是失败，则返回根结点
        return this;
    }

    return this.failure.nextState(transition);      // 跳转失败，按failure跳转
}

6.建立Fail表(核心)

Fail表保存的是状态(节点)间的一对一的关系，存储状态转移失败后应当回退的最佳状态(敲黑板，看下面的实例讲解！！！)。

以图为例，匹配she之后到达状态5，再来一个字符，状态转移失败，此时，最长后缀为he，对应路径为0-1-2。因此，状态2是状态5 fail的最佳选择，fail到状态2之后，做好了接受r的准备。

再比如，匹配his后到达状态7，此时his的最长后缀为is，但是途中没有找到is的路径，于是找次长后缀s，对应路径为0-3，因此状态7的最佳fail为3。

下面是构建方法：

  • 将深度为1的节点设为根节点，第二层中的节点的失败路径直接指向根节点
  • 为深度大于1的节点建立fail表，此处需要层序遍历，用BFS进行广度优先遍历。整个过程可以概括为一句话：设这个节点上的字母为C，沿着他父亲的失败指针走，直到找到一个节点，孩子节点也为C。然后把当前节点的fail指向刚找到的孩子节点C。如果一直走到了root都没找到，那就把fail指向root。

下面是具体的构建代码：

/**
 *  @author: Ragty
 *  @Date: 2020/4/1 16:04
 *  @Description: 建立Fail表(核心,BFS遍历)
 */
private void constructFailureStates() {
    Queue<Node> queue = new LinkedList<>();

    for (Node depthOneState : this.root.children()) {
        depthOneState.setFailure(this.root);
        queue.add(depthOneState);
    }
    this.failureStatesConstructed = true;

    while (!queue.isEmpty()) {
        Node parentNode = queue.poll();
        for (Character transition : parentNode.getTransitions()) {
            Node childNode = parentNode.find(transition);
            queue.add(childNode);
            Node failNode = parentNode.getFailure().nextState(transition);   //在这里构建failNode
            childNode.setFailure(failNode);
            childNode.addEmit(failNode.emit());					//用路径后缀构建output表
        }
    }
}

7.建立output表

output表用来记录命中的模式串，output表中的元素有两种：

  • 从初始状态到当前状态的路径本身对应的模式串（比如2号状态的he）
  • 路径的后缀所对应的模式串（比如5号状态中的he）

所以output表的构造也分为两步：

  • 第一步与字典树类似，记录完整路径所对应的模式串
  • 第二步则是找出所有路径后缀及其模式串(这一步放在了构建fail表的最后)

下面是构建代码：

/**
 *  @author: Ragty
 *  @Date: 2020/4/1 15:10
 *  @Description: 添加一个模式串(内部使用字典树构建)
 */
public void addKeyword(String keyword) {
    if (keyword == null || keyword.length() == 0) {
        return;
    }

    Node currentState = this.root;
    for (Character character : keyword.toCharArray()) {
        currentState = currentState.insert(character);
    }
    currentState.addEmit(keyword);
}

8.模式匹配

模式匹配实现的功能是，输入一段文本，输出AC自动机中所有匹配的词，下面是实现代码：

/**
 *  @author: Ragty
 *  @Date: 2020/4/1 17:43
 *  @Description: 模式匹配
 */
public Collection<Emit> parseText(String text) {
    checkForConstructedFailureStates();
    Node currentState = this.root;
    List<Emit> collectedEmits = new ArrayList<>();
    for (int position = 0; position < text.length(); position++) {
        Character character = text.charAt(position);
        currentState = currentState.nextState(character);
        Collection<String> emits = currentState.emit();
        if (emits == null || emits.isEmpty()) {
            continue;
        }
        for (String emit : emits) {
            collectedEmits.add(new Emit(position - emit.length() + 1, position, emit));
        }
    }
    return collectedEmits;
}

9.单元测试
public static void main(String[] args) {
    AhoCorasickTrie trie = new AhoCorasickTrie();
    trie.addKeyword("hers");
    trie.addKeyword("his");
    trie.addKeyword("she");
    trie.addKeyword("he");
   
    Collection<Emit> emits = trie.parseText("ushers");
    for (Emit emit : emits) {
        System.out.println(emit.start + " " + emit.end + "\t" + emit.getKeyword());
    }
}

输入文本为"ushers"时，输出结果为：

1 3	she
2 3	he
2 5	hers

10.基于双数组字典树的AC自动机

基于双数组字典树的AC自动机会进一步优化，结构上只需将原来的success表的构建由Trie树替换为DATrie，效果上与双数组字典树不相上下，原因为：

  • 汉语中的词汇都不太长，前缀树的优势占了较大比重，AC自动机的fail机制发挥不了太大作用
  • 全切分需要将结果添加到链表，也会占用时间

总结一下，当含有短模式串时，优先用双数组字典树，否则优先使用基于双数组字典树的AC自动机


11.源码
public class AhoCorasickTrie {

    private Boolean failureStatesConstructed = false;   //是否建立了failure表
    private Node root;                                  //根结点


    /**
     *  @author: Ragty
     *  @Date: 2020/4/1 13:49
     *  @Description: ACTire初始化
     */
    public AhoCorasickTrie() {
        this.root = new Node(true);
    }



    /**
     *  @author: Ragty
     *  @Date: 2020/4/1 13:54
     *  @Description: ACTrie节点(内部用字典树构建)
     *
     */
    private static class Node{
    private Map<Character, Node> map;
    private List<String> emits;         //输出
    private Node failure;               //失败中转
    private Boolean isRoot = false;     //是否为根结点


    public Node(){
        map = new HashMap<>();
        emits = new ArrayList<>();
    }


    public Node(Boolean isRoot) {
        this();
        this.isRoot = isRoot;
    }


    public Node insert(Character character) {
        Node node = this.map.get(character);
        if (node == null) {
            node = new Node();
            map.put(character, node);
        }
        return node;
    }


        public void addEmit(String keyword) {
            emits.add(keyword);
        }


        public void addEmit(Collection<String> keywords) {
            emits.addAll(keywords);
        }


        /**
         *  @author: Ragty
         *  @Date: 2020/4/1 14:22
         *  @Description: success跳转
         */
        public Node find(Character character) {
            return map.get(character);
        }


        /**
         *  @author: Ragty
         *  @Date: 2020/4/1 14:23
         *  @Description: 状态转移(此处的transition为转移的状态，可理解为接收的一个词)
         */
        private Node nextState(Character transition) {
            Node state = this.find(transition);             //先按success跳转

            if (state != null) {
                return state;
            }

            if (this.isRoot) {                              //如果跳转到根结点还是失败，则返回根结点
                return this;
            }

            return this.failure.nextState(transition);      // 跳转失败，按failure跳转
        }


        public Collection<Node> children() {
            return this.map.values();
        }


        public void setFailure(Node node) {
            failure = node;
        }


        public Node getFailure() {
            return failure;
        }


        public Set<Character> getTransitions() {
            return map.keySet();
        }


        public Collection<String> emit() {
            return this.emits == null ? Collections.<String>emptyList() : this.emits;
        }
    }



    /**
     *  @author: Ragty
     *  @Date: 2020/4/1 15:01
     *  @Description: 模式串(用于模式串匹配)
     */
    private static class Emit{
        private final String keyword;   //匹配到的模式串
        private final int start;        //起点
        private final int end;          //终点

        public Emit(final int start, final int end, final String keyword) {
            this.start = start;
            this.end = end;
            this.keyword = keyword;
        }

        public String getKeyword() {
            return this.keyword;
        }

        @Override
        public String toString() {
            return super.toString() + "=" + this.keyword;
        }
    }



    /**
     *  @author: Ragty
     *  @Date: 2020/4/1 15:10
     *  @Description: 添加一个模式串(内部使用字典树构建)
     */
    public void addKeyword(String keyword) {
        if (keyword == null || keyword.length() == 0) {
            return;
        }

        Node currentState = this.root;
        for (Character character : keyword.toCharArray()) {
            currentState = currentState.insert(character);
        }
        currentState.addEmit(keyword);          //记录完整路径的output表(第一步)
    }



    /**
     *  @author: Ragty
     *  @Date: 2020/4/1 17:43
     *  @Description: 模式匹配
     */
    public Collection<Emit> parseText(String text) {
        checkForConstructedFailureStates();
        Node currentState = this.root;
        List<Emit> collectedEmits = new ArrayList<>();
        for (int position = 0; position < text.length(); position++) {
            Character character = text.charAt(position);
            currentState = currentState.nextState(character);
            Collection<String> emits = currentState.emit();
            if (emits == null || emits.isEmpty()) {
                continue;
            }
            for (String emit : emits) {
                collectedEmits.add(new Emit(position - emit.length() + 1, position, emit));
            }
        }
        return collectedEmits;
    }



    /**
     *  @author: Ragty
     *  @Date: 2020/4/1 16:04
     *  @Description: 建立Fail表(核心,BFS遍历)
     */
    private void constructFailureStates() {
        Queue<Node> queue = new LinkedList<>();

        for (Node depthOneState : this.root.children()) {
            depthOneState.setFailure(this.root);
            queue.add(depthOneState);
        }
        this.failureStatesConstructed = true;

        while (!queue.isEmpty()) {
            Node parentNode = queue.poll();
            for (Character transition : parentNode.getTransitions()) {
                Node childNode = parentNode.find(transition);
                queue.add(childNode);
                Node failNode = parentNode.getFailure().nextState(transition);   //在这里构建failNode
                childNode.setFailure(failNode);
                childNode.addEmit(failNode.emit());                             //用路径后缀构建output表(第二步)
            }
        }
    }



    /**
     *  @author: Ragty
     *  @Date: 2020/4/1 15:28
     *  @Description: 检查是否建立了Fail表(若没建立，则建立)
     */
    private void checkForConstructedFailureStates() {
        if (!this.failureStatesConstructed) {
            constructFailureStates();
        }
    }


    public static void main(String[] args) {
        AhoCorasickTrie trie = new AhoCorasickTrie();
        trie.addKeyword("hers");
        trie.addKeyword("his");
        trie.addKeyword("she");
        trie.addKeyword("he");

        Collection<Emit> emits = trie.parseText("ushers");
        for (Emit emit : emits) {
            System.out.println(emit.start + " " + emit.end + "\t" + emit.getKeyword());
        }
    }


}
Ragty_
关注
  • 7
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
ac自动机
Insistor
05-29 465
下面开始用图学习ac自动机吧(个人比较喜欢放图,能用一张图解决的绝不叨叨) 首先给定模式串"ash","shex","bcd","sha",然后我们根据模式串建立如下trie树: 然后我们再了解下一步: ac自动机,就是在tire树的基础上,增加一个fail指针,如果当前点匹配失败,则将指针转移到fail指针指向的地方,这样就不用回溯,而可以路匹配下去了.(当前模式串后缀和fail指针指向的...
自然语言处理学习笔记（七）————字典树效率改进
laosao_66的博客
08-24 946
fail表保存的是状态间一对一的关系，存储状态转移失败后应当回退的最佳状态。举个例子：我们的模式串为“自然语言”，如果用字典树查询，以“自“为起点， 找到”自然语言“后，起点又退回到”然“继续扫描...如果扫描到”自然语言“的同时知道”然语言“、”语言“、”言”不在字典树中，则可以少查询三次，观察这三个字符串，它们共享递进式的后缀，所以可以引入后缀树。output 表中的元素有两种，一种是从初始状态到当前状态的路径本身对应的模式串（比如2号状态），另一种是路径的后缀所对应的模式串（比如5号状态）。
基于双数组trie树的AC自动机(含JAVA代码讲解)
muyuu的博客
12-06 1093
目录基于双数组trie树的AC自动机构建双数组trie树AC自动机构建trie树构建双数组构建fail和output双数组trie树AC自动机的查询 基于双数组trie树的AC自动机 前面我们已经介绍过 AC自动机 ，但在实际使用当中如果需要构建的词典树特别大，原始版本的AC自动机在做查询时耗时会比较多，而基于双数组trie树的AC自动机恰好能够弥补这一缺陷。 下面我们将基于hankcs实现的 AhoCorasickDoubleArrayTrie 代码来讲解双数组trie树的AC自动机的构建以及查询过程。
数据结构与算法笔记：基础篇 -AC自动机：如何用多模式串匹配实现敏感词过滤功能？
最新发布
chenjian723122704的专栏
06-18 659
很多支持用户发表文本内容的网站，比如 BBS，大都会有敏感词过滤功能，用来过滤掉用户输入的一些淫秽、反动、谩骂等内容。你有没有想过，这个功能是怎么实现的呢？实际上，这些功能最基本的原理就是字符串匹配算法，也就是通过维护一个敏感词字典，当用户输入一段文字内容之后，通过字符串匹配算法，来查找用户输入的这段文字，是否包含敏感词。如果有，就用 “***” 把它替换掉。我们讲过讲过好几种字符串匹配算法了，它们都可以处理这个问题。但是，对于访问量巨大的网站来说，比如淘宝，用户每天的评论数有几亿、甚至十几亿。
AC自动机算法
懒猫的脚印
08-15 1294
ac自动机，双数组
双数组AC自动机
勇往直前
12-18 1644
参看：http://linux.thai.net/~thep/datrie/datrie.html
AC自动机的实现
qq_41185795的博客
04-20 152
概述 Aho-Corasick automaton（AC自动机），该算法在1975年产生于贝尔实验室，是著名的多模匹配算法之一,该算法巧妙地将多模式串P建成一个确定有穷自动机（DFA），以待匹配字符串T作为该DFA的输入，使状态机进行状态转移（图2的0号节点为初态），当到达某些特定的状态时（终态：有模式串被匹配成功），完成模式匹配,能在 时间内完成多模式匹配（其中n为待匹配字符...
AC自动机详解+例题详解
10-25
关于AC自动机的详细的讲解+标程，还有一些例题的讲解。
Aho-Corasick 多模式匹配算法、AC自动机详解1
08-03
Aho-Corasick多模式匹配算法是计算机科学中...总结起来，Aho-Corasick算法是解决多模式匹配问题的一个强大工具，通过构建AC自动机，能够在文本搜索中实现快速高效的模式匹配，广泛应用于文本分析、生物信息学等领域。
acmain_curvewde_算法_AC自动机_
09-30
我们将通过"acmain_curvewde_算法_AC自动机_"这个主题，详细解析AC自动机的工作原理，并以acmain.cpp源代码文件为例，了解其实现细节。 AC自动机是由艾伦·科拉斯和高德纳在1975年提出的，全称为Aho-Corasick字符串...
automaton.py_guide3ld_ac_AC自动机_
09-29
**AC自动机（Aho-Corasick Automaton）详解** AC自动机是一种字符串搜索算法，由艾伦·科拉斯和高德纳在1975年提出，它结合了KMP算法和 Trie 数据结构，极大地提高了在一个文本中查找多个模式字符串的效率。在...
自己写的ac自动机，STL实现
08-29
相当给力，头文件中附带了简单的使用方法，使用istream当接口，因此你可以传入stringstream或fstream，甚至可以自己派生istream再传入，支持全文查找和增量查找两种模式，有问题可以联系我
AC自动机解读
04-23
AC自动机原理详解 介绍通过关键字查找文本
双数组AC自动机(doubleArrayTrie)的实现
hit_fantasy的专栏
12-13 4835
按照PPT上的描述写了个最简单的版本，没敢测大数据。 主要是几个表的构建： 首先构建next,base,check表。 根据失效函数的定义：父状态的失效函数输入当前字符，可得出每个状态的失效函数(要转移到的状态) 可以发现每个状态要转移到的状态是一定的，如下图： 所以可以构造一个fail表，由上述三个表来构建。 为了输出方便，又构造了一个output表。 代码如下： #incl
结合双数组Trie的AC自动机算法
weixin_34381687的博客
04-07 369
　　结合双数组Trie的AC自动机算法是一种相对比较快的词匹配算法，常见于分词系统用于分词，本文准备用伪代码结合实例的形式来讲解一下该匹配算法的实现原理 构建步骤： 　　1.Trie树的构建 首先直观感受一下Trie树： 插入模式串 ball、bat、doll、dork、dorm、do、send、sense之后形成的trie树 trie树分三步：插入（构建）、查找、删除 ...
AC算法详解
热门推荐
joylnwang的专栏
09-20 4万+
AC算法是Alfred V.Aho（《编译原理》（龙书）的作者），和Margaret J.Corasick于1974年提出（与KMP算法同年）的一个经典的多模式匹配算法，可以保证对于给定的长度为n的文本，和模式集合P{p1,p2,...pm}，在O(n)时间复杂度内，找到文本中的所有目标模式，而与模式集合的规模m无关。正如KMP算法在单模式匹配方面的突出贡献一样，AC算法对于多模式匹配算法后续的发
字符串多模式匹配：AC算法
xlxxcc的专栏
03-21 2万+
早在1975年贝尔实验室的两位研究人员Alfred V. Aho 和Margaret J. Corasick就提出了以他们的名字命名的高效的匹配算法—AC算法。该算法几乎与《KMP算法》同时问世。与KMP算法相同，AC算法时至今日仍然在模式匹配领域被广泛应用。 　　 　　AC算法是一个经典的多模式匹配算法，可以保证对于给定的长度为n的文本，和模式集合P{p1,p2,…pm}，在O(n)时间复杂度
AC自动机（数组版） 及其优化
Top_Spirit的博客
02-15 1000
之前很喜欢用链表写AC自动机，觉得很适合自己的理解。一直都没有接触数组的写法。。 然而稍微难一点的AC自动机的题，大佬们都是用数组写的，搞的我也看不懂大佬的思路。。 所以觉得重新学习一下数组的写法，但是收获还是有的，又学习了一些关于AC自动机的小优化。 struct acAuto{ int Next[Maxn][26] ; int num[Maxn], fail[Max...
double-array trie 译文+心得
zzran的专栏
01-03 1万+
自己对树是情有独钟，故在元旦放假的时候，翻译了an efficient implementation of trie structures。作者及来源就不叙述了。英文水平有限，但是尽量还原此文章的灵魂。如果有什么不对的地方，敬请各位给予指点。（http://blog.csdn.net/zzran/article/details/8461985-源码）.学习的时候要有trie的基础。 概论
AC自动机的实现 java代码
06-06
以下是AC自动机在Java中的实现代码： ```java import java.util.LinkedList; import java.util.Queue; class ACNode { public char data; public ACNode[] children = new ACNode[26]; public boolean isEndingChar = false; public int length = -1; public ACNode fail; public ACNode(char data) { this.data = data; } } class ACAutomaton { private ACNode root; public ACAutomaton() { root = new ACNode('/'); } public void insert(String text) { ACNode p = root; for (int i = 0; i < text.length(); i++) { int index = text.charAt(i) - 'a'; if (p.children[index] == null) { ACNode newNode = new ACNode(text.charAt(i)); p.children[index] = newNode; } p = p.children[index]; } p.isEndingChar = true; p.length = text.length(); } public void buildFailurePointer() { Queue<ACNode> queue = new LinkedList<>(); root.fail = null; queue.add(root); while (!queue.isEmpty()) { ACNode p = queue.remove(); for (int i = 0; i < 26; i++) { ACNode pc = p.children[i]; if (pc == null) continue; if (p == root) { pc.fail = root; } else { ACNode q = p.fail; while (q != null) { ACNode qc = q.children[pc.data - 'a']; if (qc != null) { pc.fail = qc; break; } q = q.fail; } if (q == null) { pc.fail = root; } } queue.add(pc); } } } public int match(String text) { ACNode p = root; int n = text.length(); for (int i = 0; i < n; i++) { int index = text.charAt(i) - 'a'; while (p.children[index] == null && p != root) { p = p.fail; } p = p.children[index]; if (p == null) p = root; ACNode tmp = p; while (tmp != root) { if (tmp.isEndingChar) { return i - tmp.length + 1; } tmp = tmp.fail; } } return -1; } } ``` 使用方法： ```java ACAutomaton ac = new ACAutomaton(); ac.insert("he"); ac.insert("she"); ac.insert("his"); ac.insert("hers"); ac.buildFailurePointer(); System.out.println(ac.match("ushers")); ``` 输出：2 这个例子中，AC自动机匹配到了字符串"she"的结尾，所以返回2。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值