AC自动机

2.多字符串匹配问题和Trie（字典树）：

      对于多字符串匹配问题，我们一般会用hash（散列表）或者Trie（字典树）储存。

      a.hash：

      将字符串利用hash函数映射到对应的hash值，然后将字符串插入对应函数值点的储存空间。（这里不关于hash函数的选择和具体实现方式。）

      b.Trie：

      这是一个树，输的节点有|{字符集}|个指针，如果一个单词对应的字母的x后面有字母y，那么他的y指针就指向一个新的节点。

                     
            上图是一个集合{he，hers，his，she}构成的字典树。

      c.字典树的定义：

      字典树的节点如下面，数据分为两部分；一部分是指针数组，用来指向单词的下一个字母；另一部分是数据域，存储单词结尾的标记、单词计数、或者是字符串之间映射的对应串。

[cpp]  view plain  copy

 print ?

1. typedef struct node {   
2.     type save;   
3.     node* next[LETTE_SIZE];   
4. }tnode;  

      d.新单词的插入：

      从根节点开始查找，如果单词当前字母指针不空，则沿着这个指针查找；如果为空，则插入新的节点，沿着该节点方向查找。

[cpp]  view plain  copy

 print ?

1. void insert( char* word, int l, type data )  
2. {  
3.     tnode* now = root;  
4.     for ( int i = 0 ; i < l ; ++ i ) {  
5.         if ( !now->next[word[i]-'a'] )  
6.             now->next[word[i]-'a'] = newnode();  
7.         now = now->next[word[i]-'a'];  
8.     }Deal(now->save, data);//处理相应操作  
9. }  

      新节点的插入：每次插入的新节点，初始化所有指针和数据域初始为空。

[cpp]  view plain  copy

 print ?

1. tnode* newnode()   
2. {  
3.     for ( int i = 0 ; i < 26 ; ++ i )  
4.         dict[size].next[i] = NULL;  
5.     dict[size].word = NULL;  
6.     return &dict[size ++];  
7. }  

e.单词查询：

      返回对应单词结束位置节点的save即可。

[cpp]  view plain  copy

 print ?

1. type query( char* word, int l )   
2. {  
3.     tnode* now = root;  
4.     for ( int i = 0 ; i < l ; ++ i ) {  
5.         if ( !now->next[word[i]-'a'] )   
6.             return false;  
7.         now = now->next[word[i]-'a'];  
8.     }return now->save;  
9. }  

3.AC自动机的介绍：

      在此认为大家已经有了 KMP算法以及Trie（字典树）的基础（如果，上面的讲述不够详细，还请查看相关资料）。AC自动机可以理解为 KMP算法的多模式串形式扩展。
那么什么是 AC自动机呢，通俗的说就是Trie的每个节点加上了一个fail指针，fail指针指向当前匹配失败的跳转位置，这就类似于KMP的next数组。

4.AC自动机的构造：

       既然我们知道了 AC自动机是用来做什么的，那么我们就来说一说怎么在 Trie上构造 AC自动机。

       首先，我们看一下条转时的条件，如同 KMP算法一样， AC自动机在匹配时如果当前字符匹配失败，那么利用fail指针进行跳转。由此可知如果跳转，跳转到的串的前缀，必为跳转前的模式串的后缀。由此可知，跳转的新位置的深度一定小于跳之前的节点。所以我们可以利用 bfs在 Trie上面进行 fail指针的求解。

      下面，是具体的构造过程（和KMP是一样的）。首先 root节点的fail定义为空，然后每个节点的fail都取决自己的父节点的fail指针，从父节点的fail出发，直到找到存在这个字符为边的节点（向回递归），将他的孩子赋值给寻找节点。如果找不到就指向根节点，具体参照代码：

[cpp]  view plain  copy

 print ?

1. setfail()   
2. {  
3.     Q[0] = root;   
4.     root->fail = NULL;  
5.     for ( int move = 0,save = 1 ; move < save ; ++ move ) {//利用bfs求解   
6.         tnode* now = Q[move];  
7.         for ( int i = 0 ; i < dictsize ; ++ i )  
8.             if ( now->next[i] ) {  
9.             tnode* p = now->fail;//从父节点的fail节点开始  
10.             while ( p && !p->next[i] ) p = p->fail;//寻找本节点的fail节点  
11.             now->next[i]->fail = p?p->next[i]:root;//不存在fail赋值为root      
12.             Q[save ++] = now->next[i];  
13.         }  
14.     }  
15. }  

      在前面的Trie建立了fail指针（虚线）{其实，这两个图片上的字符应该是在边上的，偷懒了，网上找的图片，有时间回来自己做一下}

4.多串匹配：

      既然已经构造好 AC自动机，下面就是写出他的最常见的操作，多串匹配。其实匹配过程很简单，利用Trie匹配字符串，如果失败利用fail指针找到下次匹配的位置即可。具体参照代码：

[cpp]  view plain  copy

 print ?

1. query( char* line )   
2. {  
3.     tnode* now = root;  
4.     for ( int i = 0 ; line[i] ; ++ i ) {  
5.         int index = ID( line[i] );//取得字符对应的边的编号  
6.         while ( now && !now->next[index] ) now = now->fail;//如果不能匹配，寻找fail指向的节点  
7.         now = now?now->next[index]:root;//失败时返回root，否则返回节点  
8.         for ( tnode* p = now ; p ; p = p->fail )  
9.             判断匹配  
10.     }  
11. }  

5.对于 AC自动机的改进：

      通过匹配的过程我们可以看出，fail是用来寻找下次跳转的位置的，跳转时的 next一定是为空的。那么我们为什么不用这些 next指针直接指向下一个跳转节点呢，那样的话，匹配时每次去 next指针的对象即可。这个被称作Trie图，具体参照代码：

[cpp]  view plain  copy

 print ?

1. setfail()   
2. {  
3.     Q[0] = root;  
4.     root->fail = NULL;  
5.     for ( int move = 0,save = 1 ; move < save ; ++ move ) {  
6.         tnode* now = Q[move];  
7.         for ( int i = 0 ; i < dictsize ; ++ i )  
8.         if ( now->next[i] ) {  
9.             tnode* p = now->fail;  
10.             while ( p && !p->next[i] ) p = p->fail;   
11.             now->next[i]->fail = p?p->next[i]:root;  
12.             Q[save ++] = now->next[i];  
13.         }else now->next[i] = now!=root?now->fail->next[i]:root;//其实只多了这一句  
14.     }  
15. }   

6.从自动机的角度理解：

      自动机可以理解成一个有向图，图中的每个节点都代表一个状态，边上对应的是识别的字符，那么每次识别一个字符就会发生一个状态转向另一个状态。有一个初始状态（root），很多个结束状态（Trie中被标记的点）。

      那么我们的匹配过程就是从 root状态出发，利用串的字符寻找下一个状态，每走一步就吃掉一个字符，如果发现到达标记状态则匹配成功。

      这是一个自动机的示例，其中箭头指向的是起始状态（S），双圈的代表结束状态（C,D,E,F）

7.时间复杂度分析：

      对于Trie的匹配来说时间复杂性为：O(max(L(Pi))L(T))其中L串的长度函数，P是模式串，T是目标串。

      对于 AC自动机来说时间复杂性为：O(L(T)+max(L(Pi))+m)气质m是模式串的数量。

      对于 Trie 图 来说时间复杂性为：O(L(T))在此的时间复杂性都是指匹配的复杂度。

      对于构造的代价是 O(sum(L(Pi)))其中sum是求和函数。

8.题目分析：

      下面对于近期所做的 AC自动机的题目加以分类总结

      a.模式匹配：这类问题一般都是统计目标串中模式串的个数。下面是oj中的题目编号，和说明：

            hdu1686 Oulipo： 寻找模式串的出现次数，可以重复及覆盖，直接求解
            hdu2087 剪花布条： 同上
            hdu2222 Keywords Search： 同上
            hdu2896 病毒侵袭： 同上
            hdu3065 病毒侵袭持续中： 同上，不过要注意非法字符直接返回root，否则会RE
            hdu3336 Count thestring： 同上上
            zoj3228 Searching the String： 同上，不过不允许覆盖，记录每个状态的最晚结束位置即可
            zoj3430 Detect the Virus： 同上上，统计很简单，主要是编码有点纠结

      b.字符串统计：这类题目一般都是求解某种串个数，可先求解状态转移矩阵然后利用矩阵乘法或 DP求解

            poj2778 DNA Sequence： 求解不包含某些子串的串的个数,利用AC自动机构造转移矩阵,然后利用矩阵乘法求解路径个数
            hdu2243 考研路茫茫——单词情结：上题的升级版，做法一样，由于长度不定最后要利用快速幂和，有点纠结
            zoj1540 Censored!： 题目和上面的类似，不过状态过多不宜使用矩阵乘法，所以利用 DP求解
            hdu2825 Wireless Password： 统计关键字不少于k的串的个数，并且每个只用一次，先利用状态压缩 DP统计 

      c.字符串构造（AC自动机+DP）：其实本组和上一组基本相同，不过都是求最优解，所以单独拿出来了，而且没什么共同点

            zoj3013 Word Segmenting： 其实这个题目本来是用字典树写的,学了AC自动机之后就优化了一下,求解单词覆盖的最小失败次数
            poj3691 DNA repair： 求解将目标串取除某些串的最少操作,改变合法状态时如果对应不同则+1,否则不变;非法则不转移
            zoj3545 Rescue the Rabbit： 这就是万恶之源了,AC自动机就是为了他学的,构造最优串,用状态压缩DP记录转移状态,最后求解
            hdu2296 Ring： 构造一个串使其权值最大长度最小,而且要字典序最小。有点纠结,DP长度短的优先,然后字典序
            hdu3341 Lost's revenge： 传说中的RE神题,由于状态计算错误,导致RE2次,其实就是DP,不过要先将状态分解在拼装
            zoj3190 Resource Archiver： 本次学习的收尾题目,传说中的神题,要先构造AC自动机,然后利用最短路优化将问题转化为TSP问题

9.结束语：

      AC自动机的总结到此结束，不久后还会更新，如果那里有错还请指出。

      最后给出本人的 AC自动机的模板，和上面题目的更加详细的题解和代码，请在本空间搜索即可。

[cpp]  view plain  copy

 print ?

1. /*  
2.     AC自动机模板：针对具体问题需要对 query和 makeID操作行修改。   
3.     进行了状态合并（如果一个串是另一个串的字串则值域可以合并），并且转化为 Tire图，  
4.     一般情况下不再使用 fail指针，而是直接使用 next指针。  
5.     如果构造某种要求的串，可构造出不包含关键字的状态转移矩阵，然后利用矩阵乘法或 DP求解。   
6. */    
7.   
8. /* AC_DFA define */  
9. #define nodesize 100001        //节点个数   
10. #define dictsize 26            //字符集大小    
11.   
12. typedef struct node1  
13. {  
14.     int    flag;            //值域   
15.     int    code;            //状态域     
16.     node1* fail;  
17.     node1* next[dictsize];  
18. }tnode;  
19. tnode  dict[nodesize+1];  
20. tnode* Q[nodesize+1];  
21. int    ID[256];   
22.   
23. class AC_DFA  
24. {  
25.     private:  
26.         int    size;  
27.         tnode* root;  
28.     public:  
29.         AC_DFA() {  
30.             makeID();  
31.             memset( dict, 0, sizeof( dict ) );  
32.             root=NULL; size=0; root=newnode();  
33.         }  
34.         void makeID() {  
35.             for ( int i = 0 ; i < 26 ; ++ i )  
36.                 ID['a'+i] = i;  
37.         }  
38.         void init() {  
39.             memset( dict, 0, sizeof( dict ) );  
40.             root=NULL; size=0; root=newnode();  
41.         }  
42.         tnode* newnode() {  
43.             dict[size].code = size;  
44.             dict[size].fail = root;  
45.             return &dict[ size ++ ];  
46.         }  
47.         void insert( char* word, int l ) {  
48.             tnode* now = root;  
49.             for ( int i = 0 ; i < l ; ++ i ) {  
50.                 if ( !now->next[ID[word[i]]] )  
51.                     now->next[ID[word[i]]] = newnode();  
52.                 now = now->next[ID[word[i]]];  
53.             }now->flag = 1;//now->flag ++ 用于统计  
54.         }  
55.         void setfail() {  
56.             Q[0] = root; root->fail = NULL;  
57.             for ( int move = 0,save = 1 ; move < save ; ++ move ) {  
58.                 tnode* now = Q[move];  
59.                 for ( int i = 0 ; i < dictsize ; ++ i )  
60.                     if ( now->next[i] ) {  
61.                         tnode* p = now->fail;  
62.                         while ( p && !p->next[i] ) p = p->fail;  
63.                         now->next[i]->fail  = p?p->next[i]:root;  
64.                         //now->next[i]->flag += now->next[i]->fail->flag;//状态合并，不能计数  
65.                         Q[save ++] = now->next[i];  
66.                     }else now->next[i] = now==root?root:now->fail->next[i];//构建 Trie图   
67.             }  
68.         }  
69.         int query( char* line, int L ) {//统计字串出现个数，可重复及交叉    
70.             int sum = 0;  
71.             tnode *temp,*now = root;  
72.             for ( int i = 0 ; i < L ; ++ i ) {  
73.                 now = now->next[ID[line[i]]];  
74.                 temp = now;  
75.                 while (temp && temp->flag) {  
76.                     sum += temp->flag;  
77.                     temp = temp->fail;  
78.                     //temp->flag = 0 用于统计时相同的单词只计数一次   
79.                 }  
80.             }  
81.             return sum;  
82.         }  
83. };  
84. /* AC_DFA  end */  

原文： http://blog.csdn.net/mobius_strip/article/details/22549517