【模式匹配】之——多模匹配 上篇（AC算法）

最新推荐文章于 2024-03-19 09:43:02 发布
最新推荐文章于 2024-03-19 09:43:02 发布
阅读量4k 收藏 5
点赞数 1
分类专栏： 模式匹配算法 文章标签： AC算法

from : http://blog.csdn.net/sun2043430/article/details/8821089


  1. 前言
  2. 多模匹配之二维数组法代码
  3. 多模匹配之二维数组法原理讲解二维数组构造方法
  4. 多模匹配过程及代码实现
  5. 二维数组法适用于模糊匹配
  6. 二维表多模匹配的局限性
  7. 二维表的优化
  8. 总结

完整的实现代码和扩展代码在下面给出的网址中可下载：


前言

多模匹配的意思在目标字符串中同时查找多个模式串，比较常用的算法为AC自动机算法，读者可以参照维基百科上的AC自动机算法介绍（http://en.wikipedia.org/wiki/Aho%E2%80%93Corasick_string_matching_algorithm）。

一般会构造一颗查找树，并建立失败跳转关系。本文我们将讲解另外一种方式，二维数组法。此二维数组法，在没有看到代码生成的二维数组之前，很难说明白它的思路，所以我将不同于以往在单模匹配中的讲解方法，先讲原理，后写代码。这里我将先给出代码，针对给定的多个模式串，构造出二维数组，然后对照生成的二维数组来讲解该方法的原理和查找过程。


多模匹配之二维数组法代码

注意：此代码中为了将所有的小写字母存放在大小为26的数组中，对每个小写字母进行了 -'a'操作。
[cpp]  view plain copy print ?
  1. #define MAX_SIG_SIZE    20  
  2. struct MULTI_PATTERN  
  3. {  
  4.     bool    bMask;  
  5.     byte    byMask;  
  6.     int     nLen;  
  7.     byte    SigData[MAX_SIG_SIZE];  
  8. };  
  9.   
  10. //we assume that, the characters in patterns are lower letters.   
  11. //so there are only 26 letters.  
  12. #define ALL_LOWER_CASE  26   
  13. #define END_FLAG        0x80  
  14.   
  15. typedef byte (*JMPTABLE)[ALL_LOWER_CASE];  
  16.   
  17. //we assume that, the characters in patterns are lower letters.  
  18. MULTI_PATTERN g_PatternTable[] =   
  19. {  
  20.     {false, 0, 5, {'o', 'b', 'a', 'm', 'a'} },  
  21.     {false, 0, 5, {'y', 'i', 'x', 'i', 'n'} },  
  22.     {false, 0, 6, {'y', 'i', 'd', 'i', 'a', 'n'} },  
  23. };  
  24.   
  25. JMPTABLE CreateJumpTable(MULTI_PATTERN patternTable[], int nLen)  
  26. {  
  27.     int         nTotalLen   = 0;  
  28.     byte        byNextRow   = 0;  
  29.     JMPTABLE    pJmpTab;  
  30.   
  31.     for (int i = 0; i < nLen; i++)  
  32.     {  
  33.         nTotalLen += patternTable[i].nLen;  
  34.     }  
  35.       
  36.     //use byte array only for study, maybe you need use integer array in project  
  37.     pJmpTab = (JMPTABLE)malloc(nTotalLen*ALL_LOWER_CASE);  
  38.     if (!pJmpTab)  
  39.     {  
  40.         return pJmpTab;  
  41.     }  
  42.     memset(pJmpTab, 0, nTotalLen*ALL_LOWER_CASE);  
  43.   
  44.     for (int i = 0; i < nLen; i++)  
  45.     {  
  46.         byte byCurRow = 0;  
  47.         for (int j = 0; j < patternTable[i].nLen; j++)  
  48.         {  
  49.             byte    cSign   = patternTable[i].SigData[j] - 'a';  
  50.             byte    cNext   = pJmpTab[byCurRow][cSign];  
  51.   
  52.             byNextRow++;  
  53.             if (cNext == 0)  
  54.             {  
  55.                 if (j == patternTable[i].nLen-1)//is the last character of the pattern, and the inner loop will over  
  56.                 {  
  57.                     pJmpTab[byCurRow][cSign] = i | END_FLAG;// 'i' indicate the pattern number  
  58.                 }  
  59.                 else  
  60.                 {  
  61.                     pJmpTab[byCurRow][cSign] = byNextRow;  
  62.                 }  
  63.                 byCurRow = byNextRow;  
  64.             }   
  65.             else  
  66.             {  
  67.                 assert(0 == (cNext & END_FLAG));//if reach a end position, the prefix of current pattern is another pattern  
  68.                 byCurRow = cNext;  
  69.             }  
  70.         }  
  71.     }  
  72.     return pJmpTab;  
  73. }  

多模匹配之二维数组法原理讲解、二维数组构造方法

调用上面的函数：

[cpp]  view plain copy print ?
  1. JMPTABLE pJmpTable = CreateJumpTable(g_PatternTable,   
  2.     sizeof(g_PatternTable)/sizeof(MULTI_PATTERN));  

将会得到一个二维数组pJmpTable ，它的维度为[16][26]，其中的16等于三个模式串

{'o', 'b', 'a', 'm', 'a'}（编号为0）

{'y', 'i', 'x', 'i', 'n'}（编号为1）

{'y', 'i', 'd', 'i', 'a', 'n'}（编号为2）

的长度之和。26代表所有的小写字母的集合。为了演示方便，所以我们先假设模式串都是小写字母。上面的代码得到如下所示的二维数组：


（表格1）（表格显示不全，可在另外一个页面中打开图片，显示完整表格）

二维数组中的值首先全部初始化为0，然后依次遍历三个模式串，首先看模式串{'o', 'b', 'a', 'm', 'a'}，第一个字符是'o'，所以第0行的第o列填写上1，意思是如果目标串出现的也是'o'（匹配上了），那么就继续匹配下一个字符，而下一个字符的信息将会存储到第1行。然后看第二个字符'b'，它的信息需要存储到第1行，所以第1行的'b'列填写2，同理第2行的'a'列填3，第3行的'm'列填4。处理最后一个字符'a’的方法和前面不同，是在对应的行列中填写一个0x80|0的数值，前面的0x80是一个标志，代表的是这里是一个模式串的末位字符，后面的0代表这是编号为0的模式串。所以第[9][n]处 = 0x81，代表的是编号为1的模式串{'y', 'i', 'x', 'i', 'n'}的结尾；第[10][n]处 = 0x82，代表的是编号为2的模式串{'y', 'i', 'd', 'i', 'a', 'n'}的结尾。

处理完编号为0的模式串之后，我们将处理编号为1的模式串，需要注意的是编号为1的模式串的第一个字符'y'的字符信息并不填写在第5行，而是需要填写到第0行去，而且编号为2的模式串的首字符信息也要填写到第0行去。这是因为我们进行多模匹配的时候都是从第0行开始的，如果不填在第0行，则首字符的比较需要多个行的参与，这就起不到同时进行多模匹配的效果了。所以我们在第[0][y]处填写6,6表示下一个字符的信息填写在第6行，下一个字符是'i'，所以[6][i] = 7。依次处理完编号为1的模式串，最后填写的是[9][n] = 81。

然后来处理编号为2的模式串{'y', 'i', 'd', 'i', 'a', 'n'}，同样第一个字符'y'要填写在第0行，这时候我们会发现[0][y]已经有数值 = 6（在处理编号1模式串的第一个字符时填上的），此时我们不改变该数值，而且需以该数值为指示，将下一个字符'i'的信息填写在第6行上，但是[6][i]正好也有数值了（处理模式串1的第2个字符时填上的）= 7，所以我们依旧不更改此数值，而且要根据该数值将下一个字符'd'的信息填写在第7行，[7][d]的值 = 0，所以我们在[7][d]处填写上0x0d（十进制的13）代表下一个字符'a'要填写在第0xd行（下一个字符'i'本身就是所有模式串组成的顺序中编号为13的字符）。


总结一下填表过程：

所有模式串的第一个字符信息要填写在第0行里面。

如果需要填写的位置已经有数值了，那么不要更改该数值，且取该数值作为下一个字符应该填写的行。

否则下一个字符按照自己出现在总序列中的顺序填写在自己对应的行中。

如果到达了模式串的结尾，则填写一个既能表示这是结尾、又包含了这是编号为几的模式串信息的数值。（在上面的代码中采用0x80|模式串编号的处理方法，如果模式串个数超过0x80个则需要扩展）


多模匹配过程及代码实现

匹配时，只需要根据生成的二维数组，来进行上一行到下一行（上一个字符到下一个字符）的跳转即可。如果跳转到某个位置时，该位置的值表示这是一个模式串的结尾，那么我们就找到了一个模式匹配位置，对应的模式串编号可以从该数值中分离出来。

举例说明，当在目标串"fobyixinabcd"中查找上述编号0,1,2三个模式串时：

首先从目标串中下标0处的字符f开始进行查表

  1. 目标串中下标0处f查表，pJmpTable[0]['f'] = 0，所以下一个字符（下标1处的'o'）还是和第0行进行试匹配
  2. 目标串中下标1处o查表，pJmpTable[0]['o'] = 1，所以下一个字符（下标2处的'b'）和第1行试匹配（这里可能是一个匹配的开始，记录为nMatchMaybe 位置 = 1）
  3. 目标串中下标2处b查表，pJmpTable[1]['b'] = 2，所以接下来看（下标3处的'y'）
  4. 目标串中下标3处y查表，pJmpTable[2]['y'] = 0，等于0表示这里没有模式串可以匹配，匹配到这里就失败了。
  5. 接下来，我们需要继续从目标串的nMatchMaybe+1位置（目标串下标2位置）重复上面的查表过程（这里产生了回溯，不是很好，用多叉树代替查表法可以无需回溯，下一篇文章对此进行介绍）直到找到匹配模式串或者到达目标串的末尾。


总结查表匹配过程：

  1. 从目标串开头的字符、表的第0行开始查二维表，查到的数组指示下一个字符该到哪一行去继续查表，记为NextRow
  2.     如果NextRow非0，该位置可能是一个匹配的开始，设置nMatchMaybe= 该位置
  3. 依据NextRow的指引继续查后面的字符
  4.     如果nMatchMaybe被设置后，查表得到的NextRow又出现了 = 0的情况（说明失配），则需要回溯到nMatchMaybe+1位置从表的第0行重新查表匹配
  5. 循环上面的过程，直到查找到表示模式串结尾的数值（找到了一个匹配位置）或到达目标串结尾。

对应查表匹配代码如下：

[cpp]  view plain copy print ?
  1. char* MultiSearch(char *p, int nLen, JMPTABLE pJmpTable, int &nIdx)  
  2. {  
  3.     int nRow = 0;  
  4.     int nMatchMaybe = 0;  
  5.     bool bSetMatchMaybe = false;  
  6.     for (int nStart = 0; nStart < nLen; nStart++)  
  7.     {  
  8.         byte byNextRow = pJmpTable[nRow][p[nStart]-'a'];  
  9.         if (0 != byNextRow)  
  10.         {  
  11.             //check whether is end of pattern or not  
  12.             if (byNextRow & END_FLAG)  
  13.             {  
  14.                 nIdx = byNextRow & (~END_FLAG);  
  15.                 return &p[nStart];  
  16.             }  
  17.             if (!bSetMatchMaybe)  
  18.             {  
  19.                 bSetMatchMaybe = true;  
  20.                 nMatchMaybe = nStart;  
  21.             }  
  22.         }  
  23.         else  
  24.         {  
  25.             if (bSetMatchMaybe)  
  26.             {  
  27.                 bSetMatchMaybe = false;  
  28.                 nStart = nMatchMaybe;  
  29.             }  
  30.         }  
  31.         nRow = byNextRow;  
  32.     }  
  33.     return NULL;  
  34. }  


上述代码看起来是一重循环，但里面对nStart进行了回溯。该代码可以稍作修改，写成如下2重循环的形式，两者实质上是一样的。

[cpp]  view plain copy print ?
  1. char* MultiSearch2(char *p, int nLen, JMPTABLE pJmpTable, int &nIdx)  
  2. {  
  3.     for (int nStart = 0; nStart < nLen; nStart++)  
  4.     {  
  5.         for (int i = nStart, nRow = 0; i < nLen; i++)  
  6.         {  
  7.             byte byNextRow = pJmpTable[nRow][p[i]-'a'];  
  8.             if (0 == byNextRow)  
  9.             {  
  10.                 break;  
  11.             }  
  12.             //check whether is end of pattern or not  
  13.             if (byNextRow & END_FLAG)  
  14.             {  
  15.                 nIdx = byNextRow & (~END_FLAG);  
  16.                 return &p[i];  
  17.             }  
  18.             nRow = byNextRow;  
  19.         }  
  20.     }  
  21.     return NULL;  
  22. }  

二维数组法适用于模糊匹配

二维数组法可以适用于模糊匹配，具体体现在填表过程中就是当遇到表示模糊匹配的位置时，在对应的行中每一列都填写下一个字符所在的行号，例如对于下面的3个模式串：

[cpp]  view plain copy print ?
  1. //in fuzzy match, the prefix at fuzzy position can not same as another pattern  
  2. //otherwise, it will make a conflict.  
  3. //the fuzzy char can not at the begin or end of the pattern, is meaningless   
  4. MULTI_PATTERN g_FuzzyPatternTable[] =   
  5. {  
  6.     {false, 0,   5, {'o', 'y', 'i', 'm', 'a'} },  
  7.     {true,  '*', 5, {'y', 'i', 'x', '*', 'n'} },  
  8.     {true,  '?', 6, {'y', 'i', 'd', 'i', '?', 'n'} },  
  9. };  

{'y', 'i', 'x', '*', 'n'}中的'*'表示模糊匹配，{'y', 'i', 'd', 'i', '?', 'n'}中的'?'表示模糊匹配。

生成二维数组的代码需要单独处理模糊匹配的位置：

[cpp]  view plain copy print ?
  1. JMPTABLE CreateFuzzyJumpTable(MULTI_PATTERN patternTable[], int nLen)  
  2. {  
  3.     int         nTotalLen   = 0;  
  4.     byte        byNextRow   = 0;  
  5.     JMPTABLE    pJmpTab;  
  6.   
  7.     //we can reduce some rows  
  8.     //1 every pattern's head char mapping in first row,  
  9.     //  so we can save one row for every pattern begin at second pattern  
  10.     //2 if a pattern's prefix is same as other pattern's prefix, the repeat part don't need new rows  
  11.     //  but, if the rows reduce, the code must modify for it  
  12.     for (int i = 0; i < nLen; i++)  
  13.     {  
  14.         nTotalLen += patternTable[i].nLen;  
  15.     }  
  16.   
  17.     //use byte array only for study, maybe you need use integer array in project  
  18.     pJmpTab = (JMPTABLE)malloc(nTotalLen*ALL_LOWER_CASE);  
  19.     if (!pJmpTab)  
  20.     {  
  21.         return pJmpTab;  
  22.     }  
  23.     memset(pJmpTab, 0, nTotalLen*ALL_LOWER_CASE);  
  24.   
  25.     for (int i = 0; i < nLen; i++)  
  26.     {  
  27.         byte byCurRow = 0;  
  28.         for (int j = 0; j < patternTable[i].nLen; j++)  
  29.         {  
  30.             byte    cSign   = patternTable[i].SigData[j];  
  31.             byNextRow++;  
  32.   
  33.             if (patternTable[i].bMask && patternTable[i].byMask == cSign)//in fuzzy match, add this branch   
  34.             {  
  35.                 FillTable(pJmpTab[byCurRow], byNextRow);  
  36.                 byCurRow = byNextRow;  
  37.                 continue;  
  38.             }  
  39.   
  40.             cSign       -= 'a';  
  41.             byte cNext   = pJmpTab[byCurRow][cSign];  
  42.             if (cNext == 0)  
  43.             {  
  44.                 if (j == patternTable[i].nLen-1)//the last character of the pattern, and the inner loop will over  
  45.                 {  
  46.                     pJmpTab[byCurRow][cSign] = i | END_FLAG;// 'i' indicate the pattern number  
  47.                 }  
  48.                 else  
  49.                 {  
  50.                     pJmpTab[byCurRow][cSign] = byNextRow;  
  51.                 }  
  52.                 byCurRow = byNextRow;  
  53.             }   
  54.             else  
  55.             {  
  56.                 assert(0 == (cNext & END_FLAG));//if reach a end position, the prefix of current pattern is another pattern  
  57.                 byCurRow = cNext;  
  58.             }  
  59.         }  
  60.     }  
  61.     return pJmpTab;  
  62. }  

用上面的代码生成的二维数组如下：


（表格2）

我们看到在第8行表示'*'的位置所有列都被填上了9，也就是说匹配到这里，不管目标字符串中是什么字母（26个小写字母中的任意一个）都匹配成功，并指示下一个待匹配字母需要到第9行去查表。

同样，第0xe行的'?'位置所有列都填上了0x0f。


二维表多模匹配的局限性

使用二维表进行多模匹配时也有一些局限性，考虑这样的两个模式串'yixin'、'yi*bc'，后面一个模式串在模糊匹配的*字符之前的字符和前面一个模式串的同样位置的字符相同，这样在处理后一个模式串的'*'字符时，会将一整行都处理成表示自己的下一个字符所在的行的数值，这样会覆盖第一个字符串中同位置的'x'在表中的信息，造成漏匹配第一个模式串的情况。

另外，如果模式串有包含关系，例如'yixin'、'yixinn',后一个模式串会覆盖掉前一个模式串的结尾标识位，或者反过来，如果先处理长的，后处理短的，短的模式串会截断长的模式串。

二维表的优化

我们查看表格1和表格2，可以看到在第5,a,b,c行（黄色背景部分）全部都是0，这些行是两个原因造成的：

  1. 每个模式串的首字符都填写在了第一行，所有从第2个模式串开始，每个模式串的首字符，可以减少一行内存开销，也就是第5行和第a行，是可以省略的，相应的后面行数值少加一个1
  2. 如果模式串前面有相同的字符，例如编号1、2的模式串都是以'yi’开头的，在处理编号为2的模式串时，会有两行和编号1模式串共用，所以造成第b,c行全部都是0。

针对这两种情况都可以缩减使用行数，降低内存开销，情况1很好处理，计算完所有行后减去（模式串个数-1）即可。

情况2比较麻烦一点，需要计算模式串开头相同的部分，所以我们申请内存时不考虑情况2可以省略的行数，但是我们可以在使用内存时不在中间产生空行，具体代码如下：

[cpp]  view plain copy print ?
  1. //CreateFuzzyJumpTable2 modify from CreateFuzzyJumpTable  
  2. //just save some rows for the reason 1(every pattern's head char mapping in first row)  
  3. //for reason 2, we can reduce rows further, but is not easy to calculation the repeat prefix  
  4. //so we do not do this, but in code we can let the redundant rows all behind the malloc memory.  
  5. JMPTABLE CreateFuzzyJumpTable2(MULTI_PATTERN patternTable[], int nLen)  
  6. {  
  7.     int         nTotalLen   = 0;  
  8.     byte        byNextRow   = 0;  
  9.     JMPTABLE    pJmpTab;  
  10.   
  11.     for (int i = 0; i < nLen; i++)  
  12.     {  
  13.         nTotalLen += patternTable[i].nLen;  
  14.     }  
  15.     nTotalLen -= nLen-1;//for reason 1  
  16.   
  17.     //use byte array only for study, maybe you need use integer array in project  
  18.     pJmpTab = (JMPTABLE)malloc(nTotalLen*ALL_LOWER_CASE);  
  19.     if (!pJmpTab)  
  20.     {  
  21.         return pJmpTab;  
  22.     }  
  23.     memset(pJmpTab, 0, nTotalLen*ALL_LOWER_CASE);  
  24.   
  25.     for (int i = 0; i < nLen; i++)  
  26.     {  
  27.         byte byCurRow = 0;  
  28.         for (int j = 0; j < patternTable[i].nLen; j++)  
  29.         {  
  30.             byte    cSign   = patternTable[i].SigData[j];  
  31.             //byNextRow++; only add this value in necessary   
  32.   
  33.             if (patternTable[i].bMask && patternTable[i].byMask == cSign)//in fuzzy match, add this branch   
  34.             {  
  35.                 byNextRow++;//need add  
  36.                 FillTable(pJmpTab[byCurRow], byNextRow);  
  37.                 byCurRow = byNextRow;  
  38.                 continue;  
  39.             }  
  40.   
  41.             cSign       -= 'a';  
  42.             byte cNext   = pJmpTab[byCurRow][cSign];  
  43.             if (cNext == 0)  
  44.             {  
  45.                 if (j == patternTable[i].nLen-1)//the last character of the pattern, and the inner loop will over  
  46.                 {  
  47.                     pJmpTab[byCurRow][cSign] = i | END_FLAG;// 'i' indicate the pattern number  
  48.                 }  
  49.                 else  
  50.                 {  
  51.                     byNextRow++;//need add  
  52.                     pJmpTab[byCurRow][cSign] = byNextRow;  
  53.                 }  
  54.                 byCurRow = byNextRow;  
  55.             }   
  56.             else  
  57.             {  
  58.                 assert(0 == (cNext & END_FLAG));//if reach a end position, the prefix of current pattern is another pattern  
  59.                 byCurRow = cNext;  
  60.             }  
  61.         }  
  62.     }  
  63.     return pJmpTab;  
  64. }  

使用上面的代码生成的二维表格如下：


3个模式串可以少申请2行的内存，即上表的e,f两行；又因为编号1,2的模式串前面的'yi'开头部分相同，所以在内存使用上会有两行没有使用（第c,d行）

改进之后的二维表不影响模式匹配过程。


总结

二维表格法进行多模匹配时，形成的表格直观、易理解，但是消耗过多内存（表格中为0的地方）；
二维表格法有模糊匹配的能力，但是需要模式串满足一定的条件（不能产生冲突）；
二维表格法不能很好地处理具有前缀包含关系的模式串。

上面的代码里面为了便于演示，假设了所有的模式串和目标串中的字符都是小写字母，且二维表是char类型的，不是int类型的，如果匹配长模式串，需要扩展到int类型，同时二维表应该扩充到256个字节空间，完整表示所有单字节字符。

完整的实现代码和扩展代码在下面给出的网址中可下载：

http://download.csdn.net/detail/sun2043430/5276263



惜海
关注
专栏目录
「一题多解」多模匹配（AC自动机 / 暴力）
Galaxy Coder 的博客
06-24 397
引子 难道模版题也可以一题多解？答案是：当然可以。 只要仔细分析题目性质并揣测出题人造数据的方法，就能用简单的暴力通过模版题。 但是，切记一点，正式比赛时为了准确性和速度，千万不要使用非主流解法。 题目链接 本人ACACAC的是洛谷的ACACAC自动机模版。 【模板】AC自动机（简单版） 解法一（384 ms） AC自动机直接上。 具体可以参考这篇博客。 代码 ...
AC自动机——解决多模匹配问题
aMonstere的博客
02-23 987
AC自动机 什么是多模匹配问题？ 有多个模式串的匹配问题，就是多模匹配问题 处理方法 多个模式串，建立成一棵字典树 和文本串的每一位对齐匹配，模拟暴力匹配算法的过程 常规多模匹配 从文本串中的每一次在字典树中看是否有可以匹配的 当匹配成功文本串中的she时，也就意味着后续一定会匹配成功he she对应了字典树中的节点P，he对应了字典树中的节点Q P和Q就是等价匹配节点，如果从P引出一条边指向Q，就可以加速匹配过程 在P下面查找节点的操作，等价于在Q下面查找节点的操作 这条等价关系边，通常在A
模式匹配之-多模匹配 上篇（AC算法）
04-19
【模式匹配】之——多模匹配 上篇（AC算法），具体讲解参阅下文： http://blog.csdn.net/sun2043430/article/details/8821089
【AC自动机】多模匹配算法
weixin_30781107的博客
05-03 141
写了个模板题，加强版借鉴大佬的代码，前置技能KMP（感觉没啥用主要是思想），字典树。 P3808 【模板】AC自动机（简单版） #include <queue> #include <cstdlib> #include <cmath> #include <cstdio> #include <string> #in...
AC多模匹配算法
《我是你的正能量》
11-08 2299
总结：AC算法的核心是三张查找表：goto、failure和output，共包含四种具体的算法，分别是计算三张查找表的算法以及AC算法本身。可以先阅读博客（http://tech.meituan.com/ac.html）了解goto表、failure表。 下述文章（http://blog.csdn.net/myjoying/article/details/7960534）博客转发。早在1975年贝
模式匹配之-多模匹配 下篇（AC算法之前缀树实现）
04-22
【模式匹配】之——多模匹配 下篇（AC算法之前缀树实现），对应文章地址： http://blog.csdn.net/sun2043430/article/details/8832496
字符串多模匹配算法之AC自动机理解心得.doc
05-07
AC自动机，全称为Aho-Corasick算法，是一种高效的字符串多模匹配算法，主要用于在一个文本中快速查找多个模式字符串。这种算法的核心在于构建一种特殊的数据结构——字典树（也被称为 Failure Function 或 Failure ...
字符串匹配2——多模式匹配(Trie树 AC自动机)
南国的技术栈
01-20 1824
前言 紧接着上一篇文章字符串匹配1，在上一篇文章里，我们主要总结归纳的是一个字符串和另一个字符串相比较。这篇文章，南国总结归纳的是两种常见的多模式匹配算法Trie树和AC自动机 多模式匹配：一个主串和多个模式串中间的匹配问题。 当然，聪明的你一定会问难道之前所学的单模式匹配的算法就不能用；爱解决问题吗？ 答案是当然可以，但是用单模式的字符串算法解决这类问题总体的时间开销就会大很多，对于这类问题 我...
多模匹配算法AC算法和单模匹配算法BM
最新发布
xkyby1992的专栏
03-19 1035
本文为多模匹配算法AC算法和单模匹配算法BM简单介绍，请有需要的同仁参考学习
AC多模匹配
08-11
最近网上找的多模匹配觉得都有点问题，索性自己写了一个。测试觉得性能还不错。
[转载]多模匹配算法(C++)
07-08
转载他人，得AC算法，值得研究！ 包括：算法分析文档，运行实例以及C++语言写的源代码！
多模匹配 ac算法
04-18
snort 里提取出来的多模匹配 ac算法，支持中文。
多模匹配算法 Wu-Manber 以及官方源码
07-16
Wu-Manber 多模匹配算法以及官方源码 http://code.google.com/p/wu-manber-com/
多模式匹配算法 WM算法
08-16
多模式匹配算法 WM算法 供大家下载参考
多模匹配算法与dictmatch实现
weixin_34411563的博客
10-10 261
多模式匹配在这里指的是在一个字符串中寻找多个模式字符字串的问题。一般来说，给出一个长字符串和很多短模式字符串，如何最快最省的求出哪些模式字符串出现在长字符串中是我们所要思考的。该算法广泛应用于关键字过滤、***检测、病毒检测、分词等等问题中。多模问题一般有Trie树，AC算法，WM算法等等。我们将首先介绍这些常见算法。 1.hash 可以单字、双字、全字、首尾字...
谈多模匹配算法-AC状态机
yang_oh的博客
07-20 966
谈一下基于trie树的AC匹配算法。 trie树，又称单词查找树、字典树，是一种树形结构，是一种哈希树的变种，是一种用于快速检索的多叉树结构。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。 AC匹配算法，由关键字组成的集合构成一个有限状态机，将要匹配的text作为输入（触发），输出命中哪些关键字。 trie树 以{he, she, his, he...
AC多模匹配算法-测试效率
《我是你的正能量》
11-08 1916
总结：AC算法对无规则匹配数据和有关联匹配数据影响不是很明显。 无论是有匹配还是无关匹配，大概遍历1G文件都需要10s左右。1G文件中都是0到9的字符。无匹配操作时，单纯遍历1G文件耗时情况[root@devvm acsmx]# ./ac 1G.txt ABCDE AAAAA BBBB KKKK EEEE Total Time: 4.1900 seconds.有关数据匹配：相关数据匹配[root@
多模式匹配算法-AC算法等
never.Xiao
08-21 5572
问题一：如果有一个关键词，然后让你在一段长文本中找出这些关键词，如何做？ 问题二：如果有10K个关键词，然后让你在一段长文本中找出这些关键词，如何做？如上问题一中，一段长文本中找一个关键词，那么就是单模式匹配。出了朴素算法（暴力算法）之外，还有一些经典的算法，例如KMP算法等。 问题二中，一段长文本中找N个关键词，那么就是多模式匹配，除了朴素算法外，也有一些经典的算法，例如AC算法、BM算法等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值