AC自动机【整理ing...】

最新推荐文章于 2019-09-28 13:37:12 发布
最新推荐文章于 2019-09-28 13:37:12 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： 专题分类整理 ACM-ICPC征途
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shuangde800/article/details/8145171
版权

今天开始刷AC自动机， 慢慢添加整理这个专辑。

鉴于目前还未开始系统地学习dp，AC自动机计划分两个阶段做，第一阶段是刷到中等的，第二阶段是刷带dp的难的AC自动机。


学习资料：

刘汝佳《算法入门经典-训练指南》 P214

http://www.cs.uku.fi/~kilpelai/BSA05/lectures/slides04.pdf

http://www.cppblog.com/mythit/archive/2009/04/21/80633.html  （自己的模板主要来自这个）

《Trie图的构建，活用与改进--06年》  用于AC自动机的改进



题目：

hdu  2222  Keywords Search                   经典入门题，套模板

hdu  2896  病毒侵袭                                 模板题，需要注意的是“可见字符”的ASCII码范围

hdu  3065  病毒侵袭持续中                       模板题，还是要注意“可见字符”。而且这题是多组测试数据，被坑了

hdu  1277  全文检索                                 也是模板题，输入处理用点技巧可以很方便

hdu  3695  Computer Virus on Planet Pandora    先把“压缩”的字符串“解码”，然后正反两次AC自动机计算



shuangde800
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AC自动机学习小记
待成熟的葡萄
08-27 1600
算法简介AC\mathrm{AC}自动机，英文Aho−Corasick automaton\mathrm{Aho-Corasick\ automaton}。1975年产生于贝尔实验室，是著名的多模式匹配算法之一。必备技能KMP\mathrm{KMP}算法，Trie\mathrm{Trie}（字典树）。算法分析AC\mathrm{AC}自动机其实就是将所有模式串放进一颗Trie\mathrm{Tri
AC自动机
glorious_dream的博客
03-17 6920
什么是AC自动机？ 能让你自动AC的代码？（显然不是） 1.AC自动机是一种有限状态自动机（说了等于没说），它常被用于多模式串的字符串匹配。 2.在学完AC自动机，笔者也总结出一句说了等于没说的话： AC自动机是以Trie的结构为基础，结合KMP的思想建立的。 （AC = KMP + Trie) 但不完全是。 前置知识：KMP 和Trie。 （很重要） 先说一下如何建AC自动机 1. 基础的Trie结构：将所有的模式串构成一棵Trie树。 2. KMP的思想：对Trie树上所有的结点构造失.
ac自动机最详细的讲解，让你一次学会ac自动机。
热门推荐
creatorx的博客
05-02 6万+
在没学ac自动机之前，觉得ac自动机是个很神奇，很高深，很难的算法，学完之后发现，ac自动机确实很神奇，很高深，但是却并不难。 我说ac自动机很神奇，在于这个算法中失配指针的妙处（好比kmp算法中的next数组），说它高深，是因为这个不是一般的算法，而是建立在两个普通算法的基础之上，而这两个算法就是kmp与字典树。所以，如果在看这篇博客之前，你还不会字典树或者kmp算法，那么请先学习字典树或者km
AC自动机 - 多模式串的匹配运用 --- HDU 2896
weixin_33686714的博客
09-30 95
病毒侵袭 Problem's Link：http://acm.hdu.edu.cn/showproblem.php?pid=2896   Mean:   略 analyse: AC自动机的运用，多模式串匹配。就是有几个细节要注意，在这些细节上卡了半天了。 1)输出的网站编号和最终的病毒网站数不是一样的； 2)next指针要设128,不然会爆栈； 3)同理，char转换为int...
初学AC自动机
CXR的博客
08-07 419
前言 一直听说ACACAC自动机是一个很难很难的算法，而且它不在NOIPNOIPNOIP提高组范围内（这才是关键），所以我一直没去学。 最近被一些字符串题坑得太惨，于是下定决心去学ACACAC自动机。 简介 ACACAC自动机是一个著名的多模字符串匹配算法，建立在KMPKMPKMP算法和TrieTrieTrie字典树的基础之上。 其实，它的本质就相当于在一棵TrieTrieTrie上...
元胞自动机理论基础.pdf
07-12
元胞自动机理论基础 元胞自动机（Cellular Automata，CA）是一种离散的、基于规则的动力系统，它由一系列分布在规则格网中的元胞组成，每个元胞都有有限的离散状态，并遵循相同的局部规则进行同步更新。这种模型的...
北京邮电大学AC自动机lab3.rar
11-16
【标题】"北京邮电大学AC自动机lab3.rar"是一个与AC自动机相关的学习资料压缩包，很可能是北京邮电大学计算机科学或信息技术课程的一部分，用于教授学生如何理解和实现AC自动机。AC自动机全称为Aho-Corasick算法，是...
ac自动机.pptx
07-14
要学AC自动机需要自备两个前置技能:KMP和trie树(其实个人感觉不会kmp也行,失配指针的概念并不难) 其中,KMP是用于一对一的字符串匹配,而trie虽然能用于多模式匹配,但是每次匹配失败都需要进行回溯,如果模式串很长的话...
元胞自动机184 模型.txt
11-16
元胞自动机184 模型.txt
元胞自动机与Matlab.pdf
08-10
元胞自动机与Matlab 元胞自动机（Cellular Automata，CA）是一种用来仿真局部规则和局部联系的方法。典型的元胞自动机是定义在网格上的，每一个点上的网格代表一个元胞与一种有限的状态。变化规则适用于每一个元胞...
AC自动机详解
总理同学的编程尝试
03-28 1411
刚刚写完了一篇关于KMP的一篇博客，在那里我就说，强烈建议同学们“进修”一下“AC自动机”。
AC自动机总结
小白菜又菜
03-30 2万+
AC自动机总结 0.引言：       由于大连现场赛的一道 AC自动机+ DP的题目(zoj3545 Rescue the Rabbit)被小媛同学推荐看 AC自动机。经过一段时间的努力，终于把 shǎ崽神牛的 AC自动机专辑题目 AK(其实还差那个高中题。。囧。。不让做)。       特别感谢：shǎ崽神牛，并附以链接：       http://www.notonlys
AC自动机初步入门详解
weixin_43888067的博客
09-28 552
前言 AC自动机（Aho-Corasick automaton）是KMP的升级版。KMP是单模匹配算法，处理在一个文本串中查找一个模式串的问题；AC自动机是多模匹配算法，能在一个文本串中同时查找多个不同的模式串。 多模块匹配问题：给定一个长度为n的文本S，以及k个平均长度为m的模式串P1,P2,…,Pn，要求搜索这些模式串出现的位置。 其实用KMP也能解决多模匹配问题，缺点是复杂度较高，需要对每个...
dancing links详解
huobengluantiao8
08-06 468
Dancing links是一种能高效实现Knuth的X算法的技术，它可以使很多搜索问题得到极大的优化。 假设x是一个双向链表中的一个节点，L[x]表示X的前驱，R[x]表示x的后继， 则R[L[x]] = R[x], L[R[x]] = L[x]这一操作可以把x从链表中移除，这是众所周知的， 当然，一个细致的程序员还会用 L[x] = R[x] = x或 L[x] = R[x] = NUL...
HDU 2196 Computer（树形dp经典）
D_Double's Journey
08-03 1万+
题意： 给出一棵树，求离每个节点最远的点的距离 思路： 代码： /**========================================== * This is a solution for ACM/ICPC p
【算法导论】排序 （四）：决策树、线性时间排序(计数、基数、桶排序)
D_Double's Journey
05-27 7240
到目前为止，一共整理总结了五大排序算法： 1、插入排序   2、冒泡排序、选择排序、交换排序（把这三种方法归为一种，因为他们的思想本质上都是一样的） 3、归并排序 4、堆排序 5、快速排序 以上五种排序都可以称为“比较排序”，顾名思义，因为他们都是基于比较元素来决定其相对位置的。 其中前两种的时间为O（n^2），归并排序和堆排序最坏O( n lg n )，快排平均O( n l
【算法导论】排序 （三）：快速排序 深入分析
D_Double's Journey
05-24 6959
五、快速排序 快速排序是最常用的一种排序算法，包括C的qsort，C++和Java的sort，都采用了快排（C++和Java的sort经过了优化，还混合了其他排序算法）。 快排最坏情况O( n^2 )，但平均效率O(n lg n)，而且这个O(n lg n)几号中隐含的常数因子很小，快排可以说是最快的排序算法，并非浪得虚名。另外它还是就地排序。 快速排序是基于分治模式的：
uva 10934 Dropping water balloons（dp | 难想）
D_Double's Journey
09-12 6016
题意 你有k个一模一样的水球，在一个n层楼的建筑物上进行测试，你想知道水球最低从几层楼往下丢可以让水球破掉。由于你很懒，所以你想要丢最少次水球来测出水球刚好破掉的最低楼层。（在最糟情况下，水球在顶楼也不会破）你可以在某一层楼丢下水球来测试，如果水球没破，你可以再捡起来继续用。
自动机的确定化和最小化 设计要求： 1. 可以使用任何语言来完成，例如：Java、C++。 2. 文法中的空字符串统一使用@表示。 3. 以文件方式读取自动机。 4. 判断读取的自动机是确定的还是不确定的自动机。 5. 若是不确定的自动机，将自动机确定化。 6. 将确定化后的自动机最小化。
最新发布
06-11
好的，我可以为您提供一个基于Python语言实现的自动机确定化和最小化的代码示例。以下是代码： ``` # 自动机类 class Automata: def __init__(self): self.states = [] # 状态集合 self.alphabet = [] # 字母表 self.transitions = {} # 转移函数 self.start_state = '' # 初始状态 self.final_states = [] # 终止状态 # 读取自动机文件 def read_file(self, file_path): with open(file_path, 'r') as f: lines = f.readlines() self.states = lines[0].strip().split(',') self.alphabet = lines[1].strip().split(',') self.transitions = dict() for line in lines[2:-2]: state, symbol, next_state = line.strip().split(',') if (state, symbol) not in self.transitions: self.transitions[(state, symbol)] = [next_state] else: self.transitions[(state, symbol)].append(next_state) self.start_state = lines[-2].strip() self.final_states = lines[-1].strip().split(',') # 判断自动机是否确定 def is_deterministic(self): for state in self.states: for symbol in self.alphabet: if (state, symbol) not in self.transitions: return False if len(self.transitions[(state, symbol)]) > 1: return False return True # 自动机确定化 def determinize(self): if self.is_deterministic(): return self else: new_states = [] new_transitions = {} new_final_states = [] unmarked_states = [] marked_states = [] new_start_state = tuple(sorted([self.start_state])) new_states.append(new_start_state) unmarked_states.append(new_start_state) while len(unmarked_states) > 0: current_state = unmarked_states.pop() marked_states.append(current_state) for symbol in self.alphabet: next_state = [] for state in current_state: if (state, symbol) in self.transitions: next_state += self.transitions[(state, symbol)] if len(next_state) > 0: next_state = tuple(sorted(list(set(next_state)))) if next_state not in new_states: new_states.append(next_state) unmarked_states.append(next_state) if (current_state, symbol) not in new_transitions: new_transitions[(current_state, symbol)] = [next_state] else: new_transitions[(current_state, symbol)].append(next_state) if set(current_state).intersection(set(self.final_states)): new_final_states.append(current_state) new_automata = Automata() new_automata.states = new_states new_automata.alphabet = self.alphabet new_automata.transitions = new_transitions new_automata.start_state = new_start_state new_automata.final_states = new_final_states return new_automata # 自动机最小化 def minimize(self): if self.is_deterministic(): new_automata = Automata() new_automata.states = self.states new_automata.alphabet = self.alphabet new_automata.transitions = self.transitions new_automata.start_state = self.start_state new_automata.final_states = self.final_states return new_automata else: dfa = self.determinize() partitions = [set(dfa.final_states), set(dfa.states) - set(dfa.final_states)] unmarked_partitions = [set(dfa.final_states)] marked_partitions = [set(dfa.states) - set(dfa.final_states)] while len(unmarked_partitions) > 0: current_partition = unmarked_partitions.pop() marked_partitions.append(current_partition) for symbol in dfa.alphabet: next_partitions = [] for partition in current_partition: next_partition = set() for state in partition: if (state, symbol) in dfa.transitions: next_partition.add(dfa.transitions[(state, symbol)][0]) else: next_partition.add(state) next_partitions.append(next_partition) for next_partition in next_partitions: if next_partition not in partitions: partitions.append(next_partition) unmarked_partitions.append(next_partition) new_states = [] new_transitions = {} new_final_states = [] for partition in partitions: new_states.append(tuple(sorted(list(partition)))) for state in new_states: for symbol in dfa.alphabet: next_state = tuple(sorted(list(set([s for p in state for s in partitions[partitions.index(p) + 1] if (p, symbol) in dfa.transitions]))))) if len(next_state) > 0: if (state, symbol) not in new_transitions: new_transitions[(state, symbol)] = [next_state] else: new_transitions[(state, symbol)].append(next_state) for state in new_states: if set([s for s in state for p in dfa.final_states if s in p]): new_final_states.append(state) new_automata = Automata() new_automata.states = new_states new_automata.alphabet = dfa.alphabet new_automata.transitions = new_transitions new_automata.start_state = tuple(sorted([dfa.start_state])) new_automata.final_states = new_final_states return new_automata ``` 这段代码实现了自动机类，并包含了读取自动机文件、判断自动机是否确定、自动机确定化、自动机最小化等方法。您可以使用该类，结合文件读取操作，来实现您的需求。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值