字符串模式匹配算法——BM、Horspool、Sunday、KMP、KR、AC算法

本文内容框架：

§1 Boyer-Moore算法

§2 Horspool算法

§3 Sunday算法

§4 KMP算算法

§5 KR算法

§6 AC自动机

§7 小结

 

 §1 Boyer-Moore（BM）算法

 

Boyer-Moore算法原理

 

Boyer-Moore算法是一种基于后缀匹配的模式串匹配算法，后缀匹配就是模式串从右到左开始比较，但模式串的移动还是从左到右的。字符串匹配的关键就是模式串的如何移动才是最高效的，Boyer-Moore为了做到这点定义了两个规则：坏字符规则和好后缀规则，下面图解给出定义：

 

 

下面分别针对利用坏字符规则和好后缀规则移动模式串进行介绍：

 

坏字符规则

1.如果坏字符没有出现在模式字符中，则直接将模式串移动到坏字符的下一个字符：

 

 （坏字符c，没有出现模式串P中，直接将P移动c的下一个位置）

2.如果坏字符出现在模式串中，则将模式串最靠近好后缀的坏字符（当然这个实现就有点繁琐）与母串的坏字符对齐：

        （注：如果模式串P是babababab，则是将第二个b与母串的b对齐）

 

好后缀规则

 

好后缀规则分三种情况

1.模式串中有子串匹配上好后缀，此时移动模式串，让该子串和好后缀对齐即可，如果超过一个子串匹配上好后缀，则选择最靠靠近好后缀的子串对齐。

 2.模式串中没有子串匹配上后后缀，此时需要寻找模式串的一个最长前缀，并让该前缀等于好后缀的后缀，寻找到该前缀后，让该前缀和好后缀对齐即可。

其实，1和2都可以看成模式串还含有好后缀串（好后缀子串也是好后缀）。

3.模式串中没有子串匹配上后后缀，并且在模式串中找不到最长前缀，让该前缀等于好后缀的后缀。此时，直接移动模式到好后缀的下一个字符。

 

 

Boyer-Moore算法步骤

 

1.对模式子串进行预处理

 

Boyer-Moore算法实现必须对模式串进行预处理，得到坏字符规则和好后缀规则移动的映射表，下面代码中MakeSkip是建立坏字符规则移动的映射表，MakeShift是建立好后缀规则的移动映射表。

MakeSkip是构造数组skip[]，skip[k]表示字符k距离模式串末尾的距离。

MakeShfit是构造数组shfit[]，shfit[k]表示模式串的以k为边界的后缀子串的最靠近的模式子串（或最前缀子串）到模式子串末尾的距离，例如：abcab，shfit[3]=3和shfit[2]=3（即都是第一个b到末尾的距离），k=2时，后缀子串为cab，这时只有最长前缀ab，shfit[2]=3。

2.从b_idx开始查找，得到坏字符和好后缀，得到最大移动距离，移动b_idx，直至b_idx到达母串的末尾。

 

 

Boyer-Moore算法实现

 

╔

C代码  

1. /* 
2.     函数：int* MakeSkip(char *, int) 
3.     目的：根据坏字符规则做预处理，建立一张坏字符表 
4.     参数： 
5.         ptrn => 模式串P 
6.         PLen => 模式串P长度 
7.     返回： 
8.         int* - 坏字符表 
9. */  
10. int* MakeSkip(char *ptrn, int pLen)  
11. {     
12.     int i;  
13.     //为建立坏字符表，申请256个int的空间  
14.     /*PS:之所以要申请256个，是因为一个字符是8位， 
15.       所以字符可能有2的8次方即256种不同情况*/  
16.     int *skip = (int*)malloc(256*sizeof(int));  
17.   
18.     if(skip == NULL)  
19.     {  
20.         fprintf(stderr, "malloc failed!");  
21.         return 0;  
22.     }     
23.   
24.     //初始化坏字符表，256个单元全部初始化为pLen，没有在模式串出现的字符距离为pLen。  
25.     for(i = 0; i < 256; i++)  
26.     {  
27.         *(skip+i) = pLen;  
28.     }  
29.   
30.     //给表中需要赋值的单元赋值，不在模式串中出现的字符就不用再赋值了  
31.     while(pLen != 0)  
32.     {  
33.         *(skip+(unsigned char)*ptrn++) = pLen--;  
34.     }  
35.   
36.     return skip;  
37. }  
38.   
39.   
40. /* 
41.     函数：int* MakeShift(char *, int) 
42.     目的：根据好后缀规则做预处理，建立一张好后缀表 
43.     参数： 
44.         ptrn => 模式串P 
45.         PLen => 模式串P长度 
46.     返回： 
47.         int* - 好后缀表 
48. */  
49. int* MakeShift(char* ptrn,int pLen)  
50. {  
51.     //为好后缀表申请pLen个int的空间  
52.     int *shift = (int*)malloc(pLen*sizeof(int));  
53.     int *sptr = shift + pLen - 1;//方便给好后缀表进行赋值的指标  
54.     char *pptr = ptrn + pLen - 1;//记录好后缀表边界位置的指标  
55.     char c;  
56.   
57.     if(shift == NULL)  
58.     {  
59.         fprintf(stderr,"malloc failed!");  
60.         return 0;  
61.     }  
62.   
63.     c = *(ptrn + pLen - 1);//保存模式串中最后一个字符，因为要反复用到它  
64.   
65.     *sptr = 1;//以最后一个字符为边界时，确定移动1的距离  
66.   
67.     pptr--;//边界移动到倒数第二个字符（这句是我自己加上去的，因为我总觉得不加上去会有BUG，大家试试“abcdd”的情况，即末尾两位重复的情况）  
68.   
69.     while(sptr-- != shift)//该最外层循环完成给好后缀表中每一个单元进行赋值的工作  
70.     {  
71.         char *p1 = ptrn + pLen - 2, *p2,*p3;  
72.           
73.         //该do...while循环完成以当前pptr所指的字符为边界时，要移动的距离  
74.         do{  
75.             while(p1 >= ptrn && *p1-- != c);//该空循环，寻找与最后一个字符c匹配的字符所指向的位置  
76.               
77.             p2 = ptrn + pLen - 2;  
78.             p3 = p1;  
79.               
80.             while(p3 >= ptrn && *p3-- == *p2-- && p2 >= pptr);//该空循环，判断在边界内字符匹配到了什么位置  
81.   
82.         }while(p3 >= ptrn && p2 >= pptr);  
83.   
84.         *sptr = shift + pLen - sptr + p2 - p3;//保存好后缀表中，以pptr所在字符为边界时，要移动的位置  
85.         /* 
86.           PS:在这里我要声明一句，*sptr = （shift + pLen - sptr） + p2 - p3; 
87.              大家看被我用括号括起来的部分，如果只需要计算字符串移动的距离，那么括号中的那部分是不需要的。 
88.              因为在字符串自左向右做匹配的时候，指标是一直向左移的，这里*sptr保存的内容，实际是指标要移动 
89.              距离，而不是字符串移动的距离。我想SNORT是出于性能上的考虑，才这么做的。           
90.         */  
91.   
92.         pptr--;//边界继续向前移动  
93.     }  
94.   
95.     return shift;  
96. }  
97.   
98.   
99. /* 
100.     函数：int* BMSearch(char *, int , char *, int, int *, int *) 
101.     目的：判断文本串T中是否包含模式串P 
102.     参数： 
103.         buf => 文本串T 
104.         blen => 文本串T长度 
105.         ptrn => 模式串P 
106.         PLen => 模式串P长度 
107.         skip => 坏字符表 
108.         shift => 好后缀表 
109.     返回： 
110.         int - 1表示成功（文本串包含模式串），0表示失败（文本串不包含模式串）。 
111. */  
112. int BMSearch(char *buf, int blen, char *ptrn, int plen, int *skip, int *shift)  
113. {  
114.     int b_idx = plen;    
115.     if (plen == 0)  
116.         return 1;  
117.     while (b_idx <= blen)//计算字符串是否匹配到了尽头  
118.     {  
119.         int p_idx = plen, skip_stride, shift_stride;  
120.         while (buf[--b_idx] == ptrn[--p_idx])//开始匹配  
121.         {  
122.             if (b_idx < 0)  
123.                 return 0;  
124.             if (p_idx == 0)  
125.             {       
126.                 return 1;  
127.             }  
128.         }  
129.         skip_stride = skip[(unsigned char)buf[b_idx]];//根据坏字符规则计算跳跃的距离  
130.         shift_stride = shift[p_idx];//根据好后缀规则计算跳跃的距离  
131.         b_idx += (skip_stride > shift_stride) ? skip_stride : shift_stride;//取大者  
132.     }  
133.     return 0;  
134. }  

 ╝②

算法的时间复杂度最差（匹配不上）是O(n×m)，最好是O(n),其中n为母串的长度，m为模式串的长度。BM算法时间复杂度最好是O(n/(m+1))

 

§2 Horspool算法

horspool算法将主串中匹配窗口的最后一个字符跟模式串中的最后一个字符比较。如果相等，继续从后向前对主串和模式串进行比较，直到完全相等或者在某个字符处不匹配为止（如下图中的α与σ失配） 。如果不匹配，则根据主串匹配窗口中的最后一个字符β在模式串中的下一个出现位置将窗口向右移动。

Horspool算法相对于Boyer-Moore算法改进了坏字符规则，Boyer-Moore算法只是将模式串P中从当前未匹配位置向右第一个坏字符与母串的坏字符（未匹配的字符）对齐进行再次匹配，Horspool算法是以当前匹配窗口中母串的最末尾的一个字符和模式串最靠近它的字符对齐，下图中β是当前匹配窗口的母串最后一个字符，将其与模式串左边最靠近的β对齐移动。

Horspool算法预处理

 

为了实现模式串的移动，必须先记录每一个字符串在模式串中距离最右边的距离：

Horspool算法实现

╔

C代码  

1. /* 
2.   * implementation of Horspool 
3.   * Author：Horspool 
4.   * Coder: Cobbliu 
5.   */  
6.  #define WORD 26  
7.  int horspool(char *T, int lenT, char *P, int lenP)  
8.  {  
9.      int d[WORD];  
10.      int i, pos, j;  
11.    
12.      for(i = 0; i != WORD; i++)  
13.          d[i] = lenP;  
14.      for(i = 0; i != (lenP-1); i++)  
15.          d[P[i]-'A'] = lenP-i-1;  
16.    
17.      pos = 0;  
18.      while(pos < (lenT-lenP)){  
19.          j = lenP-1;  
20.          while(j >= 0 && T[pos+j]==P[j])  //matching  
21.              j--;  
22.          if(j == -1)  
23.              return pos;  
24.          else //not matched  
25.              pos += d[T[pos+lenP-1]-'A'];  
26.      }  
27.    
28.      return -1;  
29.  }  

 

Horspool算法时间复杂度

 

假设主串的长度为n,模式串的长度为m，那么Horspool算法最坏情况下的时间复杂度是O(mn)，但平均情况下它的时间复杂度是O(n)。

╝④

§3 Sunday算法

Sunday算法思想跟BM算法很相似，在匹配失败时关注的是文本串中参加匹配的最末位字符的下一位字符。如果该字符没有在匹配串中出现则直接跳过，即移动步长= 匹配串长度+1；否则，同BM算法一样其移动步长=匹配串中最右端的该字符到末尾的距离+1。

Sunday算法实现（不废话直接上代码）

╔

 

C代码  

1. #include <iostream>  
2. #include <cstring>  
3. using namespace std;  
4.   
5. int sunday(const char* src, const char* des)  
6. {  
7.     int len_s = strlen(src);  
8.     int len_d = strlen(des);  
9.     int next[26] = {0};  
10.     for (int j = 0; j < 26; ++j)  
11.         next[j] = len_d + 1;  
12.     for (int j = 0; j < len_d; ++j)  
13.         next[des[j] - 'a'] = len_d - j; //记录字符到最右段的最短距离+1  
14.     //例如:des = "abcedfb"  
15.     //next = {7 1 5 4 3 2 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8}  
16.     int pos = 0;  
17.     while (pos < (len_s - len_d + 1)) //末端对齐  
18.     {  
19.         int i = pos;  
20.         int j;  
21.         for (j = 0; j < len_d; ++j, ++i)  
22.         {  
23.             if (src[i] != des[j])  
24.             {  
25.                 pos += next[src[pos + len_d] - 'a'];  
26.                 //不等于就跳跃,跳跃是核心  
27.                 break;  
28.             }  
29.         }  
30.         if ( j == len_d )  
31.             return pos;  
32.     }  
33.     return -1;  
34. }  
35.   
36.   
37. int main()  
38. {  
39.     char src[]="abcdacdaahfacabcdabcdeaa";  
40.     char des[]="abcde";  
41.     cout<<sunday(src,des)<<endl;  
42.     return 0;  
43. }  

 

╝⑤ 

 

Boyer-Moore、Horspool、Sunday算法小结

               Boyer-Moore、Horspool、Sunday算法都是基于后缀数组的匹配算法，区别在于移动的方式不一样（好像网上有些都没有说的Boyer-Moore算法的好后缀规则，有可能是优化方法吧，没有去深究，抱歉）。下面给出三种方法的对比：

╔

0 1 2 3 4 5 6 7 8 9 ... a b c a b d a a c b a b c a a b               b c a a b		0 1 2 3 4 5 6 7 8 9 ... a b c a b d a a c b a b c a a b                     b c a a b		0 1 2 3 4 5 6 7 8 9 ... a b c a b d a a c b a b c a a b                         b c a a b
(a)   Boyer-Moore		(b)   Horspool		(c)   Sunday

 

In this example, t0, ..., t4 =  a b c a b is the current text window that is compared with the pattern. Its suffix a b has matched, but the comparison c-a causes a mismatch. The bad-character heuristics of the Boyer-Moore algorithm (a) uses the "bad" text character c to determine the shift distance. The Horspool algorithm (b) uses the rightmost character b of the current text window. The Sunday algorithm (c) uses the character directly right of the text window, namely d in this example. Since d does not occur in the pattern at all, the pattern can be shifted past this position.

╝⑥

§4 Knuth-Morris-Pratt（KMP）算法

KMP算法是一种高效的前缀匹配算法，在传统蛮力（BF）匹配算法的基础上改进的地方在于每次移动的距离不是1可以是更大，没有进行回溯，BF算法的时间复杂度是O(m*n)，而KMP算法的时间复杂度是O(m+n)。

假设执行第i+1趟匹配时，如果比较模式串P中的第j个字符时不匹配，也就是有

T[i,i+1,...,i+j-1]=P[0,1,...,j-1]，T[i+j]≠P[j]  （打不了下标，就有数组的形式给出字符串）   (1)

BF算法下一趟是从目标的第i+1位置开始与模式串比较。如果匹配成功则有

T[i+1,i+2,...,i+m]=P[0,1,...m-1]                               (2)

如果模式串P有如下特征

P[0,1,...j-2]=P[1,2,...j-1]                     (3)

由（1）可知

T[i+1,i+2,...,i+j+1]=P[1,2,...j-1]                               (4)

由（3）（4）可知

T[i+1,i+2,...,i+j+1]≠P[0,1,...j-2]                               (5)

故由

 

T[i+1,i+2,....,i+m]≠P[0,1,...m-1]

所以第i+2趟是匹配可以不需要进行，因为一定不能匹配。

类似可以推得

P[0,1,...k-1]=P[j-k-1,j-k,...j-1]

这时才有

P[0,1,...k-1]=P[j-k-1,j-k,...j-1]=T[i+j-k,i+j-k+1,i+j-1]

模式串P从当前位置直接向右移动 j-k 位置，使模式串P的第 k 个字符P[k]与目标串T中的第i+j个字符对齐开始比较（前面 k 个已经匹配）。

造成BF算法效率低的主要原因是在算法执行过程中有回溯，而这些回溯是可以避免的。KMP算法的关键是在匹配失败时，确定下一次匹配的位置，设next[j]=k，表示当模式串P中第j个字符与母串T相应字符不匹配时，模式串P中应当由第K个字符与目标串中刚不匹配的字符对齐继续进行比较。

例如，模式串P="abaabcac"，其对应的next[j]如下：

 

 

i	0	1	2	3	4	5	6	7
t[i]	a	b	d	a	b	c	d	e
next[i]	-1	0	0	0	1	2	0	0

 

next数组构造

                          ╔   -1，   j=0;

            next[j]=         ║max{k| 0<k<j 且 P[0,1,...,k-1]=P[j-k,j-k+1,..j-1}

                                  ╚    0，    其他情况

next数组求解是一个递推过程，

设next[j]=k，则有

P[0,1,...k-1]=P[j-k,j-k+1,...,j-1]

 

            next[j]=         ╔ max{k| 0<k<j 且 P[0,1,...,k]=P[j-k,j-k+1,..j-1}

                                  ╚    0，    其他情况

如果P[k]=P[j]，有 next[j+1]=next[j]+1=k+1。

如果P[k]≠P[j]，有 P[0,1,...,k]≠P[j-k,j-k+1,...j],

假设next[j+1]=h+1，则有下式成立

P[0,1,...h]=P[j-h+1,j-k+1,...j]    P[h]=P[j]

又因为

P[0,1,...h-1]=P[j-h,j-k+1,...j-1]=P[k-h,k-h+1,k-1]    （next[k]=h的情况）

即此时实际只需要满足 next[k]=h（前面已经求解过）时，P[h]=P[j] 就有next[j+1]=h+1，否则（不存在这样的h）next[j+1]等于0。

由此可以得到计算next的递推公式

 

KMP算法实现

╔

 

C代码  

1.  /* ******************************************************************* 
2.     created:    2006/07/02 
3.     filename:     KMP.cpp 
4.     author:        李创 
5.                  http://www.cppblog.com/converse/  
6.                  
7.                 参考资料: 严蔚敏<<数据结构>> 
8.  
9.     purpose:    KMP字符串匹配算法的演示 
10. ******************************************************************** */   
11.    
12. #include  < stdio.h >   
13. #include  < stdlib.h >   
14. #include  < assert.h >   
15. #include  < string .h >   
16.    
17.  #define  MAX_LEN_OF_STR    30             //  字符串的最大长度   
18.    
19. typedef  struct  String                 //  这里需要的字符串数组,存放字符串及其长度   
20.  {  
21.      char     str[MAX_LEN_OF_STR];     //  字符数组   
22.       int         length;                     //  字符串的实际长度   
23.  } String,  * PString;  
24.   
25.  //  得到字符串的next数组   
26.  void  GetNextArray(PString pstr,  int  next[])  
27.  {  
28.     assert(NULL  !=  pstr);   
29.     assert(NULL  !=  next);  
30.     assert(pstr -> length  >   0 );  
31.   
32.      //  第一个字符的next值是-1,因为C中的数组是从0开始的   
33.      next[ 0 ]  =   - 1 ;  
34.      for  ( int  i  =   0 , j  =   - 1 ; i  <  pstr -> length  -   1 ; )  
35.      {  
36.          //  i是主串的游标,j是模式串的游标  
37.          //  这里的主串和模式串都是同一个字符串   
38.           if  ( - 1   ==  j  ||                          //  如果模式串游标已经回退到第一个字符   
39.              pstr -> str[i]  ==  pstr -> str[j])     //  如果匹配成功   
40.           {  
41.              //  两个游标都向前走一步   
42.               ++ i;  
43.              ++ j;  
44.              //  存放当前的next值为此时模式串的游标值   
45.              next[i]  =  j;  
46.         }   
47.          else                                  //  匹配不成功j就回退到上一个next值   
48.           {  
49.             j  =  next[j];  
50.         }   
51.     }   
52. }   
53.    
54.  //  KMP字符串模式匹配算法  
55.  //  输入: S是主串,T是模式串,pos是S中的起始位置  
56.  //  输出: 如果匹配成功返回起始位置,否则返回-1   
57.  int  KMP(PString S, PString T,  int  pos)  
58.  {  
59.     assert(NULL  !=  S);  
60.     assert(NULL  !=  T);  
61.     assert(pos  >=   0 );  
62.     assert(pos  <  S -> length);  
63.       
64.      if  (S -> length  <  T -> length)  
65.          return   - 1 ;  
66.   
67.     printf( " 主串\t = %s\n " , S -> str);  
68.     printf( " 模式串\t = %s\n " , T -> str);  
69.   
70.      int   * next  =  ( int   * )malloc(T -> length  *   sizeof ( int ));  
71.      //  得到模式串的next数组   
72.      GetNextArray(T, next);  
73.   
74.      int  i, j;  
75.      for  (i  =  pos, j  =   0 ; i  <  S -> length  &&  j  <  T -> length; )  
76.      {  
77.          //  i是主串游标,j是模式串游标   
78.           if  ( - 1   ==  j  ||                  //  模式串游标已经回退到第一个位置   
79.              S -> str[i]  ==  T -> str[j])  //  当前字符匹配成功   
80.           {  
81.              //  满足以上两种情况时两个游标都要向前进一步   
82.               ++ i;  
83.              ++ j;  
84.         }   
85.          else                          //   匹配不成功,模式串游标回退到当前字符的next值   
86.           {  
87.             j  =  next[j];  
88.         }   
89.     }   
90.    
91.     free(next);  
92.   
93.      if  (j  >=  T -> length)  
94.      {  
95.          //  匹配成功   
96.           return  i  -  T -> length;  
97.     }   
98.      else   
99.       {  
100.          //  匹配不成功   
101.           return   - 1 ;  
102.     }   
103. }  

╝③ 

§5 Karp-Rabin（KR）算法

 

Karp-Rabin算法是利用hash函数的特性进行字符串匹配的。 KR算法对模式串和循环中每一次要匹配的子串按一定的hash函数求值，如果hash值相同，才进一步比较这两个串是否真正相等。

Karp-Rabin算法适用于多个字符串匹配较好。

§6 Aho-Corasick算法

 

Aho-Corasick算法又叫AC自动机算法，是一种多模式匹配算法。Aho-Corasick算法可以在目标串查找多个模式串，出现次数以及出现的位置。

Aho-Corasick算法原理

Aho-Corasick算法主要是应用有限自动机的状态转移来模拟字符的比较，下面对有限状态机做几点说明：

上图是由多模式串{he,she,his,hers}构成的一个有限状态机：

1.该状态当字符匹配是按实线标注的状态进行转换，当所有实线路径都不满足（即下一个字符都不匹配时）按虚线状态进行转换。

2.对ushers匹配过程如下图所示：

 

当转移到红色结点时表示已经匹配并且获得模式串

Aho-Corasick算法步骤

Aho-Corasick算法和前面的算法一样都要对模式串进行预处理，预处理主要包括字典树Tire的构造，构建状态转移表（goto），失效函数（failure function），输出表（Output）。

Aho-Corasick算法包括以下3个步骤

1.构建字典树Tire

2.构建状态转移表，失效函数（failure function），输出表（Output）

3.搜索路径（进行匹配）

下面3个步骤分别进行介绍

构建字典树Tire

Tire是哈希树的变种，Tire树的边是模式串的字符，结点就是Tire的状态表，下图是多模式串{he,she,his,hers}的Tire树结构：

 

构建goto函数、failure function和Output函数                                                                                                                                                                                                

       goto函数（状态转移函数）：goto(pre,v)=next,完成这样的任务：在当前状态pre，输入字符v，得到下一个状态next，如果没有下个状态则next=failure。                                                      

       failure function：失效函数是处理当前状态是failure时的处理。                                                                                                                                                                                    

      output函数：当完成匹配是根据状态输出匹配的模式串。

 

下面是多模式串{he,she,his,hers}的goto函数，failure函数，output函数

goto函数：

failure函数

output函数

 

多模式串{he,she,his,hers}最终的有限状态机图

 

Aho-Corasick算法实现

 

 

C代码  

1.     
2. /*  
3. 程序说明：多模式串匹配的AC自动机算法  
4. 自动机算法可以参考《柔性字符串匹配》里的相应章节，讲的很清楚  
5. */    
6. #include <stdio.h>    
7. #include <string.h>    
8.      
9.      
10. const int MAXQ = 500000+10;    
11. const int MAXN = 1000000+10;    
12. const int MAXK = 26; //自动机里字符集的大小    
13. struct TrieNode    
14. {    
15.        TrieNode* fail;    
16.        TrieNode* next[MAXK];    
17.        bool danger;   //该节点是否为某模式串的终结点    
18.        int cnt;    //以该节点为终结点的模式串个数    
19.        TrieNode()    
20.        {    
21.               fail = NULL;    
22.               memset(next, NULL, sizeof(next));    
23.               danger = false;    
24.               cnt = 0;    
25.        }    
26. }*que[MAXQ], *root;    
27. //文本字符串    
28. char msg[MAXN];    
29. int   N;    
30. void TrieInsert(char *s)    
31. {    
32.        int i = 0;    
33.        TrieNode *ptr = root;    
34.        while(s[i])    
35.        {    
36.               int idx = s[i]-'a';    
37.               if(ptr->next[idx] == NULL)    
38.                      ptr->next[idx] = new TrieNode();    
39.               ptr = ptr->next[idx];    
40.               i++;    
41.        }    
42.        ptr->danger = true;    
43.        ptr->cnt++;    
44. }    
45.      
46. void Init()    
47. {    
48.        int i;    
49.        char s[100];    
50.        root = new TrieNode();    
51.        scanf("%d", &N);    
52.        for(i = 0; i < N; i++)    
53.        {    
54.               scanf("%s", s);    
55.               TrieInsert(s);    
56.        }    
57. }    
58.      
59. void Build_AC_Automation()    
60. {    
61.        int rear = 1, front = 0, i;    
62.        que[0] = root;    
63.        root->fail = NULL;    
64.        while(rear != front)    
65.        {    
66.               TrieNode *cur = que[front++];    
67.               for(i = 0; i < 26; i++)    
68.                      if(cur->next[i] != NULL)    
69.                      {    
70.                             if(cur == root)    
71.                                    cur->next[i]->fail = root;    
72.                             else    
73.                             {    
74.                                    TrieNode *ptr = cur->fail;    
75.                                    while(ptr != NULL)    
76.                                    {    
77.                                           if(ptr->next[i] != NULL)    
78.                                           {    
79.                                                  cur->next[i]->fail = ptr->next[i];    
80.                                                  if(ptr->next[i]->danger == true)    
81.                                                         cur->next[i]->danger = true;    
82.                                                  break;    
83.                                           }    
84.                                           ptr = ptr->fail;    
85.                                    }    
86.                                    if(ptr == NULL) cur->next[i]->fail = root;    
87.                             }    
88.                             que[rear++] = cur->next[i];    
89.                      }    
90.        }    
91. }    
92. int AC_Search()    
93. {    
94.        int i = 0, ans = 0;    
95.        TrieNode *ptr = root;    
96.        while(msg[i])    
97.        {    
98.               int idx = msg[i]-'a';    
99.               while(ptr->next[idx] == NULL && ptr != root) ptr = ptr->fail;    
100.               ptr = ptr->next[idx];    
101.               if(ptr == NULL) ptr = root;    
102.               TrieNode *tmp = ptr;    
103.               while(tmp != NULL && tmp->cnt != -1)    
104.               {    
105.                      ans += tmp->cnt;    
106.                      tmp->cnt = -1;    
107.                      tmp = tmp->fail;    
108.               }    
109.               i++;    
110.        }    
111.        return ans;    
112. }    
113. int main()    
114. {    
115.        int T;    
116.        scanf("%d", &T);    
117.        while(T--)    
118.        {    
119.               Init();    
120.               Build_AC_Automation();    
121.               //文本    
122.               scanf("%s", msg);    
123.               printf("%d\n", AC_Search());    
124.        }    
125.     return 0;    
126. }