AC算法 及python实现

零 导言

　　软件安全课上，老师讲了AC算法，写个博客，记一下吧。

　　那么AC算法是干啥的呢？

　　——是为了解决多模式匹配问题。换句话说，就是在大字符串S中，看看小字符串s1, s2,...有没有出现。

　　AC算法的时间复杂度是线性的，思路非常巧妙，也挺好理解的。但是有些的对于AC算法的介绍，挺难看懂的。这是因为原始的AC算法，会存在内存占用过多的问题，因为我们引入了”双数组“的方法来减少内存占用。所以，实际运用的AC算法，都是用双数组的方法写的。

一 基本信息

　　首先要说明的是，AC全称Aho-Corasick，由Alfred V.Aho和Margaret J.Corasick提出。

　　1975年，AC算法产生于贝尔实验室，该算法应用有限自动机巧妙地将字符串比较转化为状态转移。

　　AC算法是基于AC自动机的，那么什么是有限自动机呢，”形式语言与自动机“这门课里讲了，对吧。不过就算不知道，关系也不大。

　　AC自动机是一种树形自动机，包含一组状态，每个状态用一个数字代表。状态机读入文本串y中的字符，然后通过产生状态转移的方式来处理文本。

　　其实上面的都是废话，重点是下面一句。AC自动机的行为通过三个函数来指示：转向函数g、失效函数f和输出函数output。

二 具体实现与实例

　　下面以模式集{he, she, his, hers}为例，演示AC算法的工作过程。首先，对于模式集，建一棵字典树，就是下面这棵树。

　　　　

（一）转向函数

　　首先，来张图。下图中的树，结构并没有什么变化，只是每个节点对应了一个状态，从状态0到状态9。所谓状态转移g(i,c)=j，就是指状态i 读一个字符c 转移到状态j , 比如g(0,'h')=1，g(1,'e')=2。

　　　　

　　这个还是比较直观的。在建立字典树的时候，转向函数也就建立好了。

　　建立转向函数有什么用呢？你想啊，假设待匹配的字符是”hersqwew“，那么我们首先从状态0出发，然后读'h'，根据g(0,'h')=1，我们跳到状态1；然后读'e'，根据g(1,'e')=2，我们跳到状态2；按照这种步骤，一直跳到状态9，那么是不是说明待匹配的字符串中包含模式"hers"和"he"呢？

　　那么，可能会有人问了，要是在状态0读入字符‘i’，我们该跳到哪里呢？这也就是失效函数需要负责的事情。

（二）失效函数

　　相对于转向函数，失效函数的构建相对来说复杂一些。

　　失效函数，顾名思义，就是指转向函数失效之后，程序所执行的函数。转向函数失效之后，失效函数将指定下一个状态。

　　比如当我们发现g(0,'r')-1的时候，根据f(0)=0，我们跳到状态0。同理，我们发现g(2,'a')=-1的时候，根据f(2)=0，我们也跳到状态0。那么是不是都跳到状态0呢？显然不是。你试想，假设待匹配的字符串为”shis“，我们首先从状态0出发，0->3->4，然后我们我们发现g(4,'i')=-1，那么按理来说，我们应该跳到状态6，因为我们可以看得出“shis”中包含模式“his”。也就是说，应该有f(4)=1，然后通过g(1,'i')=6，我们完成从4->6的跳转。

　　

　　例子讲完了，那规律是什么呢？

　　对于f(4)=1，我们发现有g(3,'h')=4和g(0,'h')=1。

　　来个复杂点的例子，对于待匹配串“shers”，它包含"she"、"he"、"hers"三个模式。当我们读到e的时候，已经到了状态5，再读r，我们发现应该跳到2，然后到3，也就是有f(5)=2。在这里我们发现，g(3,'h')=4和g(0,'h')=1, 以及g(4,'e')=5和g(1,'e')=2。

　　规律说完了，好好理解一下。可能你会觉得构建起来，比较麻烦，但其实实现起来比较简单。

　　失效函数构建方法

　　我们先引入深度d的概念，这里的深度和我们树中常说的深度是一个意思，举个例子d(1)=1,d(6)=2。我们按照如下步骤建立失效函数：

1. f(0)=0;
2. d=1;
3. 循环直到d取最大深度{ 根据深度为d-1的函数值，计算所有深度为d的函数值; d++}

　　第3步中，”根据深度为d-1的函数值，计算所有深度为d的函数值”，举个例子，对于状态9，存在g(8,s)=9，那么f(9)=g(f(8),s)。按照这个递推式我们就可以从深度d-1的推到深度d 的是失效函数值了。

　　　　　　　　　　　　

 

（三）输出函数

 　　通过转向函数和失效函数，我们能够实现AC自动机一个个地读入字符，然后进行状态跳转。我们还缺一个输出结果的函数，比如当我们跳到了状态2，我们这时应该输出"he"，当当我们跳到了状态5，我们应该输出"she"和"he"（注意：不仅仅是"she"）。

　　

　　好了，那我们怎么建立输出函数呢？

　　分为两部分。首先，在建立转向函数g 的时候，我们就可以建立输出函数，比如output(2)="he", output(9)="hers"等。然后，在建立失效函数f 的时候，我们更新输出函数。具体来说，当我们发现f(s)=s'的时候，有 output(s)=output(s)∪output(s')。例如，有f(5)=2，则output(5)=output(5)∪output(2)={"she","he"}。

（四）匹配过程

　　在预处理阶段，我们求得转向函数g 、失效函数f 和输出函数output。结果如下(你们可以试着求一下，对一下答案)

　　转向函数 g(0,'h')=1, g(1,'e')=2, g(2,'r')=8, g(8,'s')=9,

　　　　       g(1,'i')=6, g(6,'s')=7,

　　　　　　 g(0,‘s')=3, g(3,'h')=4, g(4,'e')=5

　　　　　　 其他为-1

　　失效函数 f(4)=1, f(5)=2, f(7)=3, f(9)=3, 其他为0

　　输出函数 output(2)={"he"}, output(9)={"hers"},  output(5)={"she","he"}, output(7)={"his"} 其他为{}

　　　　

　　匹配阶段相对来说，比较简单。

　　搜索查询阶段  文本扫描开始时，初始状态为0，二输入文本y 的首字符作为当前输入字符。然后，开始按照转向函数进行状态转移。如果转移函数失败则查询失效函数，自动机状态转为失效函数定义的状态。每次的状态转移都要检查输出函数。

　　也就是说，假设待匹配字符为"hisshers"，那么状态转移为：0->1->6-> 7->3 -> 0->3 ->4-> 5->2 ->8->9，依次输出"his"、"she"、"he"、"he"、"hers"。

三 利用双数组进行优化

（一）为什么需要优化

　　在一开始，我们讲到AC算法存在内存占用过多的问题。那这是怎么回事呢？

　　对于转向函数g，比如g(i,c)=j ，它有两个输入参数: 当前状态i 和读入的字符c ，和一个输出值j 。那这些怎么存储呢？如果是C语言（不是c++, 或者python），我们肯定就是用数组存的。这样的话，这个数组就会非常大，如果使用ASCII码的话，每个状态的转向函数至少是256a个字节（a为存储一个状态所占的字节数）。然而，这个数组中大量的元素都为-1（NULL），也就是有大量的内存被浪费。

　　于是，我们引入了双数组的改进方法。

（二）怎么通过双数组优化

　　双数组，但实际上有三个数组：next数组、base数组和check数组。（我也不知道为什么叫双数组*_*，可能是因为双数组方法的灵魂是base和check数组吧）

　　假设我们已经计算出next、base和check，那么转向函数的伪代码将会是这样的

1 2 3 4 5 6

def g_index(current_state, ch):<br>　　     next_state=next[&current_state+base[current_state]+ch]     if check[next_state]==curent_state:         return next_state      else:         return -1

　　下面分别解释一下三个数组

　　next数组 　　next为转向函数表，下标是位置偏移量，输出是状态值。

　　base数组 　　下标是状态值，输出是base值。Next表中当前状态为s，输入为c时，假设应跳转为状态t，状态t在Next表中的位置=状态S的位置+状态S的Base值+输入c的ASCII码值。

　　check数组 　　下标是状态值，输出是下标状态的父状态的值。

　　　　　　

　　其实，说这么多，倒不如一个例子来的简单。

　　例子

　　（一）

　　　　

　　（二）

　　　　

　　（三）

　　　　

　　（四）

　　　　

四 python代码　

　　下面的AC算法并未使用双数组的优化方法，而是使用了python中的字典。因为本人认为，使用字典，代码写起来更容易。

　　此外，感谢junboli指出了代码中的错误，现已修正。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127

# python3 from collections import defaultdict class Node:     def __init__(self,state_num,ch=None):         self.state_num = state_num         self.ch = ch         self.children = [] class Trie(Node):     """     实现了一个简单的字典树     """     def __init__(self):         Node.__init__(self,0)     def init(self):         self._state_num_max = 0         self.goto_dic = defaultdict(lambda :-1)         self.fail_dic = defaultdict(int)         self.output_dic = defaultdict(list)     def build(self,patterns):         """         参数 patterns 如['he', 'she', 'his', 'hers']         """         for pattern in patterns:             self._build_for_each_pattern(pattern)         self._build_fail()               def _build_for_each_pattern(self,pattern):         """         将pattern添加到当前的字典树中         """         current = self         for ch in pattern:             # 判断字符 ch 是否为节点 current 的子节点             index = self._ch_exist_in_node_children(current,ch)             # 不存在 添加新节点并转向             if index == -1:                 current = self._add_child_and_goto(current,ch)             # 存在 直接 goto             else:                 current = current.children[index]         self.output_dic[current.state_num] = [pattern]     def _ch_exist_in_node_children(self,current,ch):         """         判断字符 ch 是否为节点 current 的子节点，如果是则返回位置，否则返回-1         """         for index in range(len(current.children)):             child = current.children[index]             if child.ch == ch:                 return index         return -1     def _add_child_and_goto(self,current,ch):         """         在当前的字典树中添加新节点并转向         新节点的编号为 当前最大状态编号+1         """         self._state_num_max += 1         next_node = Node(self._state_num_max,ch)         current.children.append(next_node)         # 修改转向函数         self.goto_dic[(current.state_num,ch)] = self._state_num_max         return  next_node     def _build_fail(self):         node_at_level = self.children         while node_at_level:             node_at_next_level = []             for parent in node_at_level:                 node_at_next_level.extend(parent.children)                 for child in parent.children:                     v = self.fail_dic[parent.state_num]                     while self.goto_dic[(v,child.ch)] == -1 and v != 0:                         v = self.fail_dic[v]                     fail_value = self.goto_dic[(v,child.ch)]                     self.fail_dic[child.state_num] = fail_value                     if self.fail_dic[child.state_num] != 0:                         self.output_dic[child.state_num].extend(self.output_dic[fail_value])             node_at_level = node_at_next_level class AC(Trie):     def __init__(self):         Trie.__init__(self)     def init(self,patterns):         Trie.init(self)         self.build(patterns)     def goto(self,s,ch):         if s == 0:             if (s,ch) not in self.goto_dic:                 return 0         return self.goto_dic[(s,ch)]     def fail(self,s):         return self.fail_dic[s]     def output(self,s):         return self.output_dic[s]     def search(self,text):         current_state = 0         ch_index = 0         while ch_index < len(text):             ch = text[ch_index]             if self.goto(current_state,ch) == -1:                 current_state = self.fail(current_state)             current_state = self.goto(current_state,ch)             patterns = self.output(current_state)             if patterns:                    print (current_state,*patterns)             ch_index += 1 if __name__ == "__main__":     ac = AC()     ac.init(['hert', 'this', 'ishe', 'hit','it'])     ac.search("ithisherti")

　　

　原文链接：http://www.superzhang.site/blog/AC-algorithm-and-its-python-implementation/