AC自动机——文章中是否出现多个字符串

最新推荐文章于 2024-01-28 22:37:20 发布
最新推荐文章于 2024-01-28 22:37:20 发布
阅读量434 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 AC自动机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dawnto/article/details/121338454
版权

在这里插入图片描述

package ACautomaton

import (
	"testing"
)

/*
Ac 自动机解决的问题
在一个大文章当中，给你一批候选串，想知道文章当中命中了哪些候选串，返回List 其中包含命中的字符串
如何高效一点

如何理解fail指针
候选串建立一些前缀树，每个候选串都建立前缀树
“abcd”
"bcd"
"ce"



建立前缀树
                       0
                  a / b|  \c
                   0   0   0
                b /   c|    \ e
                 0     0     0
              c /   d /
               0     0
            d /
             0


每一个节点多出一个fail指针
头节点的fail指针指向空
第一级孩子的fail指针指向头
再接下来的fail指针策略
1.假设来到X节点，我要设置我的某一个孩子节点的fail指针， 它指向哪
首先看，我是怎么来到我的孩子的，假设路径'b'
 X -- > 甲 有走向b的路径
 |b      \
 子-----> 甲子
假设X的fail指针指向甲, 如果甲节点也有走向b的路，我就把我孩子的fail指针指向它的孩子


1.我自己的fail指针指向空，让我孩子的fail指针直接指向我
2.当前节点的fail指针指向空，让我孩子的指针指向头


 X---fail---> nil
 \
  X子------fail----->head


                    head------>nil
                /         \    `----.
              |           |          \
          0  |       0   /       0   |
        a | |      b | /         |  /
      1   0'  .----->0'2 .-----> 0' 3
        b | /      c | /      e |
          0'         0'         0
        c |        d |
          0          0
        d |
          0


                           0
                  a /     b|        \c
                   0       0         0
                b /       c|         \ e
                 0         0          0
              c /       d /
               0         0
            d /
             0


总逻辑，一条
首先来到父亲节点，设置孩子节点M的fail指针，假设路径叫a， 从父节点先跳一次，找到X节点,若X节点也有指向a的路，则把节点M的fail指向X的孩子节点
如果X节点没有指向a的路，则从X往外跳，重复以上步骤，若某个节点的fail指针指向空，仍没有找到fail的指向，则将M节点的fail指针指向头节点
遇到空的前一个一定是头


加fail指针的时机是建立好前缀树之后，再按照宽度优先遍历，建立fail指针

前缀树是压缩的，a开头的只能有一个
 */





type Node struct {
	end   int // 有多少个字符串以该节点结尾
	fail  *Node
	nexts []*Node
}

func NewNode() *Node {
	return &Node{
		end: 0,
		fail: nil,
		nexts: make([]*Node,26),// 26个字母
	}
}

type ACAutomation struct {
	root *Node
}

func NewACAutomation() *ACAutomation {
	return &ACAutomation{
		root: NewNode(),
	}
}


// 你有多少个匹配串，就调用多少次insert
func (ac *ACAutomation) insert(str string)  {
    cur := ac.root
	index := 0
	for i := 0; i < len(str); i++ {
		index = int(str[i] - 'a')
		if cur.nexts[index] == nil {
			cur.nexts[index] = NewNode()
		}
		cur = cur.nexts[index]
	}
	cur.end++
}



type Queue struct {
	elem   []interface{}
	length int
}

func NewQueue() *Queue {
	return &Queue{
		elem:   make([]interface{},0),
	}
}


func (q *Queue) IsEmpty() bool {
	return q.length == 0
}

func (q *Queue) Add(value interface{})  {
	q.elem = append(q.elem,value)
	q.length++
}

func (q *Queue) Poll() interface{} {
	res := q.elem[0]
	q.elem = q.elem[1:]
	q.length--
	return res
}

func (ac *ACAutomation) build() {
	queue := NewQueue()
	queue.Add(ac.root)
	var cur, cfail *Node
	for !queue.IsEmpty() {
		cur = queue.Poll().(*Node) // 父
		for  i := 0; i < 26; i++ { // 下级所有的路
			if cur.nexts[i] != nil { // 该路下有子节点
				cur.nexts[i].fail = ac.root // 初始时先设置一个值
				cfail = cur.fail
				for cfail != nil { // cur不是头节点
					if cfail.nexts[i] != nil {
						cur.nexts[i].fail = cfail.nexts[i]
						break
					}
					cfail = cfail.fail
				}
				queue.Add(cur.nexts[i])
			}
		}
	}
}

func (ac *ACAutomation)containNum(str string) int {
	cur := ac.root
	var follow *Node
	index := 0
	ans := 0
	for i := 0; i < len(str); i++ {
		index = int(str[i] - 'a')
		for cur.nexts[index] == nil && cur != ac.root {
			cur = cur.fail
		}

		if cur.nexts[index] != nil {
			cur = cur.nexts[index]
		}else {
			cur = ac.root
		}

		follow = cur
		for follow != ac.root {
			if follow.end == -1 {
				break
			}
			{ // 不同的需求，在这一段{ }之间修改
				ans += follow.end
				follow.end = -1
			} // 不同的需求，在这一段{ }之间修改
			follow = follow.fail
		}
	}
	return ans
}

func TestAc(t *testing.T)  {
	ac := NewACAutomation()
	ac.insert("dhe")
	ac.insert("he")
	ac.insert("c")
	ac.insert("w")
	ac.build()
	t.Log(ac.containNum("wchedhe"))
}

注：本人不是算法的原作者，我只是用Go重写了Java的代码，参照该地址，版权归原作者所有！

package Ac2

import "testing"

// 前缀树的节点
type Node struct {
	// 如果一个node，end为空，不是结尾
	// 如果end不为空，表示这个点是某个字符串的结尾，end的值就是这个字符串
	end string
	// 只有在上面的end变量不为空的时候，endUse才有意义
	// 表示，这个字符串之前有没有加入过答案
	endUse bool
	fail *Node
	nexts []*Node
}

func NewNode() *Node {
	return &Node{
		end:    "",
		endUse: false,
		fail:   nil,
		nexts:  make([]*Node,26),
	}
}

type ACAutomation struct {
	root *Node
}

func NewACAutomation() *ACAutomation {
	return &ACAutomation{
		root: NewNode(),
	}
}

func (ac *ACAutomation) insert(str string)  {
	cur := ac.root
	index := 0
	for i := 0; i < len(str); i++ {
		index = int(str[i] - 'a')
		if cur.nexts[index] == nil {
			cur.nexts[index] = NewNode()
		}
		cur = cur.nexts[index];
	}
	cur.end = str
}


func (ac *ACAutomation) build() {
	queue := NewQueue()
	queue.Add(ac.root)
	var cur, cfail *Node
	for !queue.IsEmpty() {
		// 某个父亲，cur
		cur = queue.Poll().(*Node)
		for i := 0; i < 26; i++ { // 所有的路
			// cur -> 父亲  i号儿子，必须把i号儿子的fail指针设置好！
			if cur.nexts[i] != nil { // 如果真的有i号儿子
				cur.nexts[i].fail = ac.root
				cfail = cur.fail
				for cfail != nil {
					if cfail.nexts[i] != nil {
						cur.nexts[i].fail = cfail.nexts[i]
						break
					}
					cfail = cfail.fail
				}
				queue.Add(cur.nexts[i])
			}
		}
	}
}

func (ac *ACAutomation) containWords(str string) []string {

	cur := ac.root
	var follow *Node
	index := 0
	ans := make([]string,0)
	for i := 0; i < len(str); i++ {
		index = int(str[i] - 'a') // 路
		// 如果当前字符在这条路上没配出来，就随着fail方向走向下条路径
		for cur.nexts[index] == nil && cur != ac.root {
			cur = cur.fail
		}
		// 1) 现在来到的路径，是可以继续匹配的
		// 2) 现在来到的节点，就是前缀树的根节点

		if cur.nexts[index] != nil {
			cur = cur.nexts[index]
		}else {
			cur = ac.root
		}

		follow = cur
		for follow != ac.root {
			if follow.endUse {
				break
			}
			// 不同的需求，在这一段之间修改
			if follow.end != "" {
				ans= append(ans,follow.end)
				follow.endUse = true
			}
			// 不同的需求，在这一段之间修改
			follow = follow.fail
		}
	}
	return ans
}

func TestAc(t *testing.T)  {
	ac := NewACAutomation()
	ac.insert("dhe")
	ac.insert("he")
	ac.insert("abcdheks")
	// 设置fail指针
	ac.build()

	contains := ac.containWords("abcdhekskdjfafhasldkflskdjhwqaeruv");
	for _, word := range contains {
		t.Log(word)
	}
}







type Queue struct {
	elem   []interface{}
	length int
}

func NewQueue() *Queue {
	return &Queue{
		elem:   make([]interface{},0),
	}
}


func (q *Queue) IsEmpty() bool {
	return q.length == 0
}

func (q *Queue) Add(value interface{})  {
	q.elem = append(q.elem,value)
	q.length++
}

func (q *Queue) Poll() interface{} {
	res := q.elem[0]
	q.elem = q.elem[1:]
	q.length--
	return res
}

func TestQueue(t *testing.T)  {
	q := NewQueue()
	q.Add(1)
	q.Add(2)
	q.Add(3)
	for !q.IsEmpty() {
		t.Log(q.Poll())
	}
}

注：本人不是算法的原作者，我只是用Go重写了Java的代码，参照该地址，版权归原作者所有！

metabit
关注
专栏目录
AC自动机——解决多模匹配问题
aMonstere的博客
02-23 998
AC自动机 什么是多模匹配问题？ 有多个模式串的匹配问题，就是多模匹配问题 处理方法 多个模式串，建立成一棵字典树 和文本串的每一位对齐匹配，模拟暴力匹配算法的过程 常规多模匹配 从文本串中的每一次在字典树中看是否有可以匹配的 当匹配成功文本串中的she时，也就意味着后续一定会匹配成功he she对应了字典树中的节点P，he对应了字典树中的节点Q P和Q就是等价匹配节点，如果从P引出一条边指向Q，就可以加速匹配过程 在P下面查找节点的操作，等价于在Q下面查找节点的操作 这条等价关系边，通常在A
字符串多模匹配算法之AC自动机理解心得.doc
05-07
AC自动机，全称为Aho-Corasick算法，是一种高效的字符串多模匹配算法，主要用于在一个文本中快速查找多个模式字符串。这种算法的核心在于构建一种特殊的数据结构——字典树（也被称为 Failure Function 或 Failure ...
ac自动机——字符串多模式匹配算法
带带我咯的博客
07-20 233
在学习了Trie树后紧接着要学习的就是ac自动机了，很多人说ac自动机 = KMP算法 + Trie树，或者说是树上的KMP算法，我觉得的ac自动机理解起来要比KMP简单一些。只是脑子里想应该是很难理解的，多画画图就会理解ac自动机的匹配模式和过程。 我参考的是下面两个博客很详细： https://www.cnblogs.com/cmmdc/p/7337611.html https://www.cnblogs.com/hyfhaha/p/10802604.html 模板题用来验证代码的正确性：https:/
AC自动机——搜索关键词+单词
测试
10-21 478
构建next数组过程，首先看回kmp算法里面的next数组的构建过程，在下图里面的j代表的具体意义实际上是next[i-1]，也就是第i-1个字符与前缀的最大匹配长度，下面的while循环里面a[i]和a[j+1]的比较实际上就是第i个字符和第i-1个字符能够匹配上的最大长度的前缀的下一个进行比较，如果相同就能让第i个字符的next[i]==next[i-1]+1；ac自动机里面的next数组存的是以当前字母结尾的字符串与从开头开始的字符串的最大匹配长度的字符串的指针。思路：没想好，不写先。
pyahocorasick——基于AC自动机的python高效字符串匹配实践
Together_CZ的博客
09-12 1053
pyahocorasick——基于AC自动机的python高效字符串匹配实践
ac自动机 匹配最长前缀_AC自动机——多模式串匹配的算法思想
weixin_39551366的博客
12-20 126
标准KMP算法用于单一模式串的匹配，即在母串中寻求一个模式串的匹配，但是现在又存在这样的一个问题，如果同时给出多个模式串，要求找到这一系列模式串在母串存在的匹配个数，我们应该如何处理呢？基于KMP算法，我们能够想到的一个朴素算法就是，枚举这多个模式串，然后进行多次KMP算法，这个过程中完成计数，假设这里有n个模式串，那么整个算法的复杂度大约是O(n*m)，m是母串的长度，这里的时间复杂度是粗略估计...
AC自动机:在一篇文章paper字符串中，搜索查找一批matches字符串，看看有哪些字符串能匹配上
weixin_46838716的博客
06-02 297
1）AC自动机就是利用前缀树的fail指针，绕过已经匹配过的后缀前str，这个str在matches中其他的字符串里面做最长的前缀，这个最长的前缀str不要再跟paper重复对比了，这就是加速的本质！！！ 2）你必须熟悉前缀树！构建前缀树的步骤，pass，end的含义，本题中fail，end，usedEnd的含义，就能做文章匹配了。 3）笔试求AC，可以不考虑空间复杂度，但是面试既要考虑时间复杂度最优，也要考虑空间复杂度最优。 ......
匹配多个字符串——AC自动机
来自Fop_zz的辣鸡题解或教程
03-16 954
真·AC自动机：zyy AC自动机这个东西。。名字真的是没得吐槽=_= 它运用了kmp算法的next思想（体现于后文的fail指针）以及trie的数据结构（字母树） kmp如果不会的话还可以，trie不会的话。。建议还是先去学trie吧 我看了好久。。才看懂这个蜜汁自动机先看一下模版题来了解AC自动机的用处： Hdu2222 题意：有n段小字符串，求其中有多少段出现在了一个大字符串中
AC 自动机——多模式串匹配
weixin_34289744的博客
12-15 309
网站上的敏感词过滤是怎么实现的呢？ 实际上，这些功能最基本的原理就是字符串匹配算法，也就是通过维护一个敏感词的字典，当用户输入一段文字内容后，通过字符串匹配算法来检查用户输入的内容是否包含敏感词。 BF、RK、BM、KMP 算法都是针对只有一个模式串的字符串匹配算法，而要实现一个高性能的敏感词过滤系统，就需要用到多模式匹配算法了。 1. ...
字符串——多模匹配——ac自动机(1.0模板)
T.J的博客
08-03 177
/***** ① ac 自动机 fail 用大了最大公共前后缀，这个与kmp略有不同：是 一个单词（也不能说是单词，一个单词的前缀子串）的后缀 后另一个单词的前缀。 ② 匹配时：文本串r走到底 然后fail指针回溯相当于l 右移， （如果暴力匹配过 你就是知道l r表示的是什么） ③时间复杂度: m个单词 每个单词平均长度为len2 文本串的长度为 len 节点个数x ...
AC自动机.doc————电子版_doc版
09-17
AC自动机的主要目的是解决多模式字符串匹配问题，即在一个大文本中查找是否存在多个预定义的小字符串。这种算法由Aho和Corasick在1975年提出，因此得名Aho-Corasick自动机。 首先，我们需要理解Trie（字典树或前缀...
数据结构与算法笔记——用Go语言描述
Go的全部
11-16 3738
数据结构与算法 用Go语言描述 位运算 位运算——奇淫技巧 位运算——二进制截断和插入 位运算——交换奇偶位 位运算——回文判断 位运算——LeetCode1386. 安排电影院座位 位运算——面试题 17.19. 消失的两个数字 位运算——求1比特数 位运算——476. 数字的补数 位运算——出现一次的数，出现两次的数 查找 二分——有序数组中查找元素 二分——有序数组中，某个数最左或最右的位置 二分——无序无重复元素数组的局部最小值的索引 排序 排序——选择排序 排序——冒泡排序 排序——插入排序 .
go标准库——优先级队列的实现
Go的全部
10-24 3098
package heap_test // priorty_queue是以个带权值观念的queue，它允许加入新元素，移除旧元素，审视元素值等功能 import ( "container/heap" "fmt" "testing" ) // Item 是我们在优先队列中管理的东西 type Item struct { value string // The value of the item; arbitrary. priority int // 队列中项目的优先级 // The
动态规划——编辑距离问题
最新发布
Go的全部
01-28 2526
动态规划——编辑距离问题
堆定制——1.0强耦合版
Go的全部
10-24 2237
package heap import ( "encoding/json" "fmt" "testing" ) //什么时候需要手写堆，需要更新堆中的某些值，让他自然有序 //迪杰斯特拉算法 就需要这类算法 // 从每个节点扫一遍， 代价会非常高 // 用户：可能对于某一个已经存在的对象，修改值， 在堆上找到，调整到该去的位置，logN级别 type student struct { Name string Age int Height int Weight int
上升子序列的最大长度，递归-记忆化搜索-动态规划三步走
Go的全部
01-27 2188
题目描述： 小明有一个数组，他想从数组任意元素开始向后遍历，找出所有上升子序列，并计算出最长的上升子序列的长度。 上升子序列的最大长度，递归-记忆化搜索-动态规划三步走
search——Bloom Filter
Go的全部
01-19 2185
BitMap
堆排序——Go标准库堆，排序一个几乎有序的数组
Go的全部
10-24 2144
已知一个几乎有序的数组。几乎有序是指，如果把数组排好序的话，每个元素移动的距离一定不超过k,并且k相对于数组的长度来讲是比较小的。 请选择一个合适的排序策略，对这个数组进行排序是最好的。 [x,x,x,x,xx,x] k = 5 排序的话，每一个数字去的位置不超过5 生成一个小根堆 i - i 0 i - i + 1 1 i - i - 1 1 前k + 1 个数进小根堆 堆中0 - 5 的位置会来到0位置 从小根堆中弹出最小值放到0位置，6位置的数不可能来到0位置，因为距离是
AC自动机算法：高效字符串匹配
AC自动机（Aho-Corasick Algorithm）是一种用于高效处理字符串精确匹配问题的算法，特别适用于在一个大的文本（目标串T）中查找多个模式串（模式串集合P）的情况。它的时间复杂度为O(n+m+z)，其中n代表所有模式串的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

metabit

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值