数据结构-AC自动机

Trie Tree 多模式匹配

Trie Tree 本质:就是利用字符串之间的公共前缀,将重复的前缀合并到在一起

Trie Tree 和 AC 自动机都是多模式串匹配算法。

单模式串匹配算法:一个模式串和一个主串之间进行匹配。每次匹配都需要扫描一遍主串,效率低下。

多模式串匹配算法:多个模式串和一个主串之间进行匹配。只需扫描一遍主串,效率高。

多模式串匹配算法应用场景:敏感词过滤。

只需要一次构建 Trie Tree,一直在匹配。动态更新敏感词词典,更新 Trie Tree。

[图解字典树多模匹配过程]

Trie 树的多模式匹配算法

python 复制代码
class TrieNode:
    def __init__(self, data=None):
        self.data = data
        self.children = {}

class Trie:
    def __init__(self):
        self.root = TrieNode()

    def insert(self, word):
        p = self.root
        for i in range(len(word)):
            if word[i] not in p.children:
                p.children[word[i]] = TrieNode()
            p = p.children[word[i]]
        p.data = word

    def find(self, pattern):
        p = self.root
        for i in range(len(pattern)):
            if pattern[i] not in p.children: return
            p = p.children[pattern[i]]
        return p.data

    def multi_match(self, text):
        res = []
        for i in range(len(text)):
            p = self.root
            for j in range(i, len(text)):
                if text[j] not in p.children: break
                p = p.children[text[j]]
                if p.data: res.append(p.data)

        return res

if __name__ == "__main__":
    trie = Trie()
    # 加载敏感词表
    trie.insert("格力")
    trie.insert("苹果")
    trie.insert("和服")

    text = "格力电器和苹果公司的商品和服务非常不错"
    print(trie.multi_match(text))
# 输出:['格力', '苹果', '和服']

基于 Trie 树这种处理方式,有点类似单模式串匹配的 BF 算法。单模式串匹配算法中,KMP 进入了 next 数组,让匹配失败时,尽可能将模式串往后多移动几位。

AC 自动机

AC 自动机就是在 Trie 树之上,加了类似 KMP 的 next 数组,只不过此处的 next 数组是构建在树上

AC 自动机与 Trie Tree 关系,类似BF 算法与 KMP算法 的关系。

AC 自动机在前缀树的基础上,为前缀树上的每个节点建立一棵==后缀树==,节省了大量的查询。

AC 自动的构建步骤:

  1. 构建 Trie Tree
  2. 在 Trie Tree 上构建失败指针(相当于 KMP 中的失效函数 next 数组)

构建 Trie Tree 看 Trie Tree 介绍文档。

着重介绍构建失败指针。

构建失败指针

假设有 4 个模式串:c,bc,bcd,abcd 和 主串 abcd

假设沿着 Trie Tree 走到了 p 点,p 点的失败指针就是字符串 abc ,跟所有模式串前缀匹配的最长可匹配后缀子串

abc 的后缀子串:bc,c。将 bc ,c 在Trie Tree 中匹配,找到最长匹配前缀,那个后缀子串叫做:最长可匹配后缀子串

计算每个节点的失败指针看似复杂,其实,如果将树中同一深度的结点放到同一层,那么失败结点只可能出现在他所在层的上一层。我们可以逐层依次来求解每个节点的失败指针。所以,失败指针的构建过程,就是一个按层遍历树的过程

注意:root 节点的失败指针为 NULL,也就是指向自己。

如上图:节点 p 的失败指针指向 q 节点。那么 qc 节点是否能在 q 节点的子节点找到?如果找到pc 的失败指针就指向 qc,如果找不到,那么再从 q 节点的失败指针中尝试寻找( q = q.fail ),如果一直没有找到,那么 pc 的失败指针指向根节点。

python 复制代码
class AcNode:
    def __init__(self):
        self.data = None
        self.children = {}
        # 当节点为结束结点时,模式串的长度
        self.length = -1
        # 失败指针
        self.fail = None

class AC:
    def __init__(self):
        self.root = AcNode()

    def add(self, word):
        p = self.root
        for char in word:
            # 只有结束结点才写入 data
            if char not in p.children:
                p.children[char] = AcNode()
            p = p.children[char]
        p.data = word
        p.length = len(word)

    def build_failure_pointer(self):
        queue = [self.root]
        while queue:
            p = queue.pop(0)
            for key, pc in p.children.items():
                q = p.fail
                while q:
                    qc = q.children.get(key, None)
                    if qc:
                        pc.fail = qc
                        break
                    q = q.fail
                if q is None:
                    pc.fail = self.root
                queue.append(pc)

if __name__ == "__main__":
    ac = AC()
    # 加载敏感词表
    ac.add("格力")
    ac.add("苹果")
    ac.add("和服")

    ac.build_failure_pointer()

AC 自动机构架完毕后:

时间复杂度分析:

Trie Tree 构建时间复杂度:O( m * len ) m 敏感词个数,len 敏感词的平均长度。

上构建失败指针

  1. 每个节点构建失败指针,都需要从当前层,一层一层向上找,最大值为树的深度( len ),
  2. 树的结点树为 k ,那么构建失败指针的时间复杂度为:O( len * k)

注意:AC 自动机一旦构建完毕后,不会频繁改动。所以对匹配效率不会影响。

AC 自动机 构建时间为:O(m*len) + O(len * k)

匹配

匹配过程:

主串 i = 0 开始,AC 自动机指针从 root 开始,b 是模式串,a 是主串,

if b[ i ] in p.children ,检测一系列失败指针为结尾的路径是否是模式串,处理完毕后,i += 1

if b[ i ] not in p.children ,p = p.fail。然后继续这两个过程。

python 复制代码
    def match(self, text):
        res = []
        p = self.root
        for i, char in enumerate(text):
            # 一个新 char ,通过 fail 寻找合适 node,开始查询
            while char not in p.children and p != self.root:
                p = p.fail

            # 如果没有匹配,从 root 开始。
            p = p.children[char] if char in p.children else self.root
            tmp = p
            while tmp != self.root:
                if tmp.data is not None:
                    pos = i - tmp.length + 1
                    print('匹配起始下标' + str(pos) + ";长度:" + str(tmp.length))
                    res.append(tmp.data)
                tmp = tmp.fail
        return res
      
      
if __name__ == "__main__":
    ac = AC()
    # 加载敏感词表
    ac.add("格力")
    ac.add("苹果")
    ac.add("和服")

    ac.build_failure_pointer()
    text = "格力电器和苹果公司的商品和服务非常不错"
    print(ac.match(text))

时间复杂度分析:

与失败指针构建类似,for 遍历每个字符时,最耗时在 while 循环中,这一部分时间复杂度也是:O( len ),所以总的匹配时间复杂度:O(n * len) 。一般敏感词并不会很长,实际情况,可能近似:O( n )

在极端情况下,AC 自动机才会退化为 Trie Tree

相关推荐
萧鼎1 小时前
Python并发编程库:Asyncio的异步编程实战
开发语言·数据库·python·异步
学地理的小胖砸1 小时前
【一些关于Python的信息和帮助】
开发语言·python
疯一样的码农1 小时前
Python 继承、多态、封装、抽象
开发语言·python
^velpro^1 小时前
数据库连接池的创建
java·开发语言·数据库
ChoSeitaku1 小时前
链表交集相关算法题|AB链表公共元素生成链表C|AB链表交集存放于A|连续子序列|相交链表求交点位置(C)
数据结构·考研·链表
秋の花1 小时前
【JAVA基础】Java集合基础
java·开发语言·windows
偷心编程1 小时前
双向链表专题
数据结构
香菜大丸1 小时前
链表的归并排序
数据结构·算法·链表
jrrz08281 小时前
LeetCode 热题100(七)【链表】(1)
数据结构·c++·算法·leetcode·链表
小松学前端1 小时前
第六章 7.0 LinkList
java·开发语言·网络