AC自动机

一:概念

首先简要介绍一下AC自动机:Aho-Corasick automation,该算法在1975年产生于贝尔实验室,是著名的多模匹配算法之一。一个常见的例子就是给出n个单词,再给出一段文章(长度是m),让你找出有多少个单词在文章里出现过。要搞懂AC自动机,先得有字典树Trie的基础知识(也有人说需要KMP的知识,我觉得暂且不要理会这个。但是在看这篇文章之前,Trie字典树,你是必须要先搞懂,如果你还不理解Trie,请参考http://blog.csdn.net/laojiu_/article/details/50838421)。

与其他字符匹配不同,KMP算法是单模式串的字符匹配算法,AC自动机是多模式串的字符匹配算法。匹配时间复杂度是O(N),线性复杂度!


二:算法过程(三步走)

举个例子,假如现在给出5个模式串:say she shr he her 

主串是:yasherhs

现在问你,这5个模式串有几个出现在主串里的?

OK,现在就拿这个例子来完成这个算法的过程。

第一步:构建Trie树,这很简单的了。构建好后,出现下图:



第二步:构建失败指针

构建失败指针是AC自动机的核心所在,玩转了它也就玩转了AC自动机,失败指针就是,当我的主串在trie树中进行匹配的时候,如果当前节点不能再继续进行匹配,那么我们就会走到当前节点的fail节点继续进行匹配。

构造失败指针的过程概括起来就一句话:对于root的儿子节点,fail指针直接指向root,其他的所有节点(用到了BFS和队列),设这个节点上的字母为C,沿着它父亲的失败指针走,直到走到一个节点,它的儿子中也有字母为C的节点。然后把当前节点的失败指针指向那个字母为C的节点。如果一直走到了root都没找到,那就把失败指针指向root。

构建好后,如下图:


针对图中红线的”h,e“这两个节点,我们想起了什么呢?对”her“中的”e“来说,e到root距离的n个字符恰好与”she“中的e向上的n个字符相等

第三步:模式匹配

匹配过程分两种情况:

(1)  当前字符匹配成功,表示从当前节点沿着树边有一条路径可以到达目标字符,此时只需沿该路径走向下一个节点继续匹配即可,目标字符串指针移向下个字符继续匹配;

(2)  当前字符不匹配,则去当前节点失败指针所指向的字符继续匹配,匹配过程随着指针指向root结束。重复这2个过程中的任意一个,直到模式串走到结尾为止。


注意:主串所有字符在匹配完后都必须要走fail节点来结束自己的旅途,相当于一个回旋,这样做的目的防止包含节点被忽略掉。

见下图,比如:我匹配到了"she",必然会匹配到该字符串的后缀”he",要想在程序中匹配到,则必须节点要走失败指针来结束自己的旅途。



三:完整代码

[cpp]  view plain  copy
 print ?
  1. #include  
  2. #include  
  3.   
  4. #define MAX 26//假设只出现26个小写英文字母  
  5. #define ROW 4  
  6. #define COLUMN 10  
  7.   
  8. using namespace std;  
  9.   
  10. char pattern[ROW][COLUMN] = { "nihao","hao","hs","hsr" };  
  11. char *s = "sdmfhsgnshejfgnihaofhsrnihao";  
  12.   
  13. struct Node  
  14. {  
  15.     int index;//存储模式串的下标  
  16.     char x;  
  17.     Node *parent;  
  18.     Node *next[MAX];  
  19.     Node *fail;  
  20.     Node()  
  21.     {  
  22.         index = -1;//pattern数组下标从0开始,-1代表该节点不是单词结尾  
  23.         fail = nullptr;   
  24.         parent = nullptr;  
  25.         for (int i = 0; i < MAX; i++)  
  26.             next[i] = nullptr;  
  27.     }  
  28. };  
  29.   
  30. class ACTree  
  31. {  
  32. public:  
  33.     Node *root;  
  34.     ACTree() { root = new Node; root->fail = root; }  
  35.   
  36.     void Add(const char *ch, int index);              //第一步  
  37.     void NodeToQueue(Node *node, queue &q);    //  
  38.     void BuildFailPointer();                          //第二步  
  39.     void ACSearch(const char *s);                     //第三步  
  40. };  
  41.   
  42. int main()   
  43. {  
  44.     ACTree tree;  
  45.   
  46.     for (int i = 0; i < ROW; i++)  
  47.         tree.Add(pattern[i], i);  
  48.   
  49.     tree.BuildFailPointer();  
  50.   
  51.     cout << "待匹配字符串为(依次5个一组的输出):\n";  
  52.     for (int i = 1; i <= strlen(s); i++)  
  53.     {  
  54.         cout << s[i];  
  55.         if (i % 5 == 0)  
  56.             cout << "  ";  
  57.     }  
  58.     cout << endl << endl;  
  59.   
  60.     cout << "匹配结果如下:\n";  
  61.     cout << "位置\t" << "编号\t" << "模式\n";  
  62.   
  63.     tree.ACSearch(s);  
  64.   
  65.     return 0;  
  66. }  
  67.   
  68. void ACTree::Add(const char *ch,int index)  
  69. {  
  70.     int len = strlen(ch);  
  71.     if (len == 0) return;  
  72.   
  73.     Node *p = root;  
  74.   
  75.     for (int i = 0; i < len; i++)  
  76.     {  
  77.         int k = ch[i] - 'a';  
  78.   
  79.         if (p->next[k] == nullptr)  
  80.         {  
  81.             p->next[k] = new Node;  
  82.             p->next[k]->parent = p;  
  83.             p->next[k]->x = ch[i];  
  84.         }  
  85.           
  86.         p = p->next[k];  
  87.     }  
  88.   
  89.     p->index = index;//注意,在此保证输入的模式串不重复,否则index会被覆盖  
  90. }  
  91.   
  92. void ACTree::NodeToQueue(Node *node, queue &q)  
  93. {  
  94.     if (node != nullptr)  
  95.     {  
  96.         for (int i = 0; i < MAX; i++)  
  97.         {  
  98.             if (node->next[i])  
  99.                 q.push(node->next[i]);//不知道这是干嘛的??想想BFS层次遍历的那些事  
  100.         }  
  101.     }  
  102. }  
  103.   
  104. void ACTree::BuildFailPointer()  
  105. {  
  106.     queue q;  
  107.   
  108.     for (int i = 0; i < MAX; i++)  
  109.     {  
  110.         if (root->next[i])  
  111.         {  
  112.             NodeToQueue(root->next[i], q);//注意,切不可写成q.push(root->next[i]);  
  113.             root->next[i]->fail = root;  
  114.         }  
  115.     }  
  116.   
  117.     Node *parent, *p;  
  118.     char ch;  
  119.     while (!q.empty())  
  120.     {  
  121.         p = q.front();  
  122.         ch = p->x;  
  123.         parent = p->parent;  
  124.         q.pop();  
  125.         NodeToQueue(p, q);  
  126.   
  127.         while (1)  
  128.         {  
  129.             if (parent->fail->next[ch - 'a'] != nullptr)  
  130.             {  
  131.                 p->fail = parent->fail->next[ch - 'a'];  
  132.                 break;  
  133.             }  
  134.             else  
  135.             {  
  136.                 if (parent->fail == root)  
  137.                 {  
  138.                     p->fail = root;  
  139.                     break;  
  140.                 }  
  141.                 else  
  142.                     parent = parent->fail->parent;  
  143.             }  
  144.         }  
  145.     }  
  146. }  
  147.   
  148. void ACTree::ACSearch(const char *s)  
  149. {  
  150.     int len = strlen(s);  
  151.     if (len == 0) return;  
  152.   
  153.     Node *p = root;  
  154.   
  155.     int i = 0;  
  156.     while (i < len)  
  157.     {  
  158.         int k = s[i] - 'a';  
  159.   
  160.         if (p->next[k] != nullptr)  
  161.         {  
  162.             p = p->next[k];  
  163.   
  164.             if (p->index != -1)  
  165.                 cout << i - strlen(pattern[p->index]) + 1 << "\t" << p->index << "\t" << pattern[p->index] << endl;  
  166.   
  167.             i++;  
  168.         }  
  169.         else  
  170.         {  
  171.             if (p == root)  
  172.                 i++;  
  173.             else  
  174.             {  
  175.                 p = p->fail;  
  176.                 if (p->index != -1)  
  177.                     cout << i - strlen(pattern[p->index]) + 1 << "\t" << p->index << "\t" << pattern[p->index] << endl;  
  178.             }  
  179.         }  
  180.     }  
  181.   
  182.     while (p != root)  
  183.     {  
  184.         p = p->fail;  
  185.         if(p->index!=-1)  
  186.             cout << i - strlen(pattern[p->index]) + 1 << "\t" << p->index << "\t" << pattern[p->index] << endl;  
  187.     }  
  188. }  

四:数据测试



你可能感兴趣的:(leetcode)