字符串匹配

转自：http://mindlee.net/2011/11/25/string-matching/，   感谢 @酷~行天下

字符串匹配的朴素算法

 字符串 T = abcabaabcabac，字符串 P = abaa，判断P是否是T的子串，就是字符串匹配问题了，T 叫做文本（Text） ，P 叫做模式（Pattern），所以正确描述是，找出所有在文本 T = abcabaabcabac 中模式 P = abaa 的所有出现。字符串匹配的用处应该很明显，经常使用的全文查找功能，Ctrl + F，用的应该就是字符串匹配算法，更高级的还有DNA序列中搜寻特定模式等。

     模式 P 在文本 T 中出现一次，在位移 s = 3 处。如果用最朴素（Naive）的匹配算法，也可以解决，两个 for 循环搞定，代码倒是巨短，但是效率很低，因为有很多不必要的比较，朴素匹配算法，最坏情况下，运行时间为：O((n – m + 1)m)。

朴素算法代码实现：

[cpp] view plaincopy

1. /* 
2. 运行结果： 
3. _________________________ 
4. 朴素算法，匹配位置是：7 
5. */  
6. #include<iostream>  
7. #include<cstdio>  
8. #include<cstring>  
9. using namespace std;  
10.    
11. //朴素匹配算法  
12. void NativeStringMatcher(const char *T, const char *P) {  
13.     int n = strlen(T);  
14.     int m = strlen(P);  
15.     for (int j, i = 0; i < n - m; i++) {  
16.         for (j = 0; j < m; j++) {  
17.             if (T[i + j] != P[j]) {  
18.                 break;  
19.             }  
20.         }  
21.         if (j == m) {  
22.             printf("朴素算法，匹配位置是：%d\n", i + 1);  
23.         }  
24.     }  
25. }  
26.    
27. int main() {  
28.     const char *T = "2359023141526739921";  
29.     const char *P = "31415";  
30.     NativeStringMatcher(T, P);  
31.     return 0;  
32. }  

下面是四个高级算法，Rabin-Karp算法，Knuth-Morris-Pratt算法，字典树，AC自动机。

先验知识，记号与术语：

1）用 Σ* 表示用字母表Σ中的所有有限长度的字符串的集合 ；

2）字符串 x 的长度用 |x| 表示。

3）x 和 y 的连接表示为 xy，长度为| x |+| y |

4）x = yw，y 是 x 的前缀，w 是 x 的后缀

一、Rabin-Karp算法

     Rabin-Karp算法由 Rabin 和 Karp 提出，预处理时间为 O（m），最坏情况下运行时间为O((n – m + 1)m)，似乎和朴素算法差不多，但是它最坏情况出现的几率太小，所以平均情况很好。Rabin-Karp算法的核心思想是通过对字符串进行哈稀运算（散列运算），即给文本中 模式长度 的字符串哈希出一个数值，开始只需比较这个数值即可，之后在数值的基础上再用朴素算法比较字符串，利用散列函数可以很容易的吧字母转化为数字，这里假定字符串就是数字字符。比如字符串 31415 对应于十进制的31415。

     已知模式 P[1.……m]，设 p 表示其相应十进制数地值，类似地， 对于给定的文本T[1.……n]. 用 t_s 表示长度为 m 的子字符串 T[s + 1 ‥ s + m]（ s = 0, 1, . . . , n – m）， t_s = p 当且仅当 [s + 1 ‥ s + m] = P[1 ‥m]；因此s是有效位移当且仅当 t_s = p，可以通过把 p 与每一个 t_s 值进行比较。

可以用霍纳规则(Horner’s rule) 在Θ(m) 的时间内计算p的值 ：

                       p = P[m] + 10 (P[m - 1] + 10(P[m - 2] + · · · + 10(P[2] + 10P[1]) )).

     类似地，可以在Θ(m)时间内，根据T[1..m]计算出t₀ 的值。为了在Θ(n – m) 时间内计算出剩余的值t₁, t₂, . . . , t_n-m 可以在常数的时间内根据t_s计算出t_s+1，总结出公式：

                     t_{s + 1} = 10 （t_s – 10^m-1 T[s + 1]） + T[s + m + 1]………………公式1

     单看公式很难理解，来个例子：如果m= 5，t_s = 31415, 我们去掉高位数字T [s + 1] = 3，然后在加入一个低位数字T [s+ 5 + 1]（假设为2)，得到：t_s+1 = 10(31415 – 10000 • 3) + 2 = 14152。

     当然还有一个问题是，计算中 p 和 t_s 的值可能太大，超出计算机字长，不能方便地进行处理。如果 p 包含m 个字符，那么， 关于在 p 上地每次算术运算需要“常数”时间这一假设就不合理了，幸运的是，对这一问题存在一个简单的补救方法，对一个合适的模 q 来计算 p 和 t_s 的模，每个字符是一个十进制数，因为 p 和 t₀  以及 公式1 计算过程都可以对模 q 进行，所以可以在 Θ(m) 时间内计算出模 q 的 p 值，在 Θ(n – m + 1) 时间内计算出模 q 的所有 t_s 值，通常选模 q 为一个素数，使得 10q 正好为一个计算机字长，单精度算术运算就可以执行所有必要的运算过程。 一般情况下，采用d进制的字母表{0, 1, . . . , d – 1}, 所选的 q 要满足 d * q < 字长，调整 公式1， 使其为：

                t_{s + 1} = （d（t_s – T[s + 1] * h） + T[s + m + 1]） mod q

     其中的h = d ^m-1 (mod q)，但是加入模q后，由t_s ≡ p (mod q)不能说明 t_s = p. 但t_s � p (mod q), 可以说明 t_s ≠ p，因此当t_s ≡ p (mod q)时， 再用朴素的字符串匹配算法验证t_s = p。. 如果q足够大，可以期望伪命中很少出现。

     如图（a）是一个文本字符串，阴影部分长度为5，模13为7。b）所有长度为5的窗口都计算出了模13的值，当然，出现两个值匹配的地方，第一个是合法匹配，第二个是伪命中点，不管是合法的，还是伪的，都进行朴素匹配，当然不匹配的，直接按照（c）图往后推进即可。伪代码：

RABIN-KARP-MATCHER(T, P, d, q)
1 n ← length[T]
2 m ← length[P]
3 h ← dm-1 mod q
4 p ← 0
5 t0 ← 0
6 for i ← 1 to m           ▹ Preprocessing.
7     do p ← (dp + P[i]) mod q
8        t0 ← (dt0 + T[i]) mod q
9 for s ← 0 to n – m       ▹ Matching.
10     do if p = ts
11           then if P[1 ‥ m] = T [s + 1 ‥ s + m]
12                   then print "Pattern occurs with shift" s
13        if s < n – m
14           then ts+1 ← (d(ts – T[s + 1]h) + T[s + m + 1]) mod q

代码实现：

[cpp] view plaincopy

1. /* 
2. 运行结果： 
3. _________________________ 
4. t1 = 8 
5. t2 = 9 
6. t3 = 3 
7. t4 = 11 
8. t5 = 0 
9. t6 = 1 
10. t7 = 7 
11. 匹配位置是：7 
12. t8 = 8 
13. t9 = 4 
14. t10 = 5 
15. t11 = 10 
16. t12 = 11 
17. t13 = 7 
18. 伪命中点：13 
19. t14 = 9 
20. */  
21. #include<iostream>  
22. #include<cstdio>  
23. #include<cstring>  
24. #include<cmath>  
25. #include<algorithm>  
26. using namespace std;  
27.    
28. //朴素匹配算法，用于RabinKarp调用  
29. bool NativeStringMatcher(const char *T, const char *P) {  
30.     int n = strlen(T);  
31.     int m = strlen(P);  
32.     for (int j, i = 0; i < n - m; i++) {  
33.         for (j = 0; j < m; j++) {  
34.             if (T[i + j] != P[j]) {  
35.                 break;  
36.             }  
37.         }  
38.         if (j == m) {  
39.             return true;  
40.         }  
41.     }  
42.     return false;  
43. }  
44.    
45. //RabinKarp算法  
46. void RabinKarp(const char *T, const char *P, int d, int q) {  
47.     int n = strlen(T);  
48.     int m = strlen(P);  
49.    
50.     int h = 1;  
51.     for (int i = 0; i < m - 1; i++) {  
52.         h *= d;//pow可能会越界，所以用乘法  
53.         if (h >= q) {  
54.             h %= q;  
55.         }  
56.     }  
57.    
58.     int p = 0;  
59.     int t = 0;  
60.     for (int i = 0; i < m; i++) {  
61.         p = (d * p + (P[i] - '0')) % q;  
62.         t = (d * t + (T[i] - '0')) % q;  
63.     }  
64.    
65.     for (int i = 0; i < n - m; i++) {  
66.         printf("t%d = %d\n", i + 1, t);  
67.         if (p == t) {  
68.             if (NativeStringMatcher(T + i, P)) {  
69.                 printf("匹配位置是：%d\n", NativeStringMatcher(T + i, P) + i);  
70.             } else {  
71.                 printf("伪命中点：%d\n", i + 1);  
72.             }  
73.         }   
74.    
75.         if (i < n - m) {  
76.             t = (d * (t - h * (T[i] - '0')) + T[i + m] - '0') % q;  
77.             if (t < 0) {  
78.                 t += q;  
79.             }  
80.         }  
81.     }  
82. }  
83.    
84. int main() {  
85.     const char *T = "2359023141526739921";  
86.     const char *P = "31415";  
87.     RabinKarp(T, P, 10, 13);  
88.     return 0;  
89. }  

二、Knuth-Morris-Pratt算法

     仨人设计的算法，所以简称KMP算法，KMP算法预处理时间Θ（m），匹配时间Θ（n），KMP算法用到了一个辅助数组π[1，m]，这个数组记录模式与其自身的位移进行匹配的信息，这些信息可以避免在朴素匹配算法中的无用位移测试，KMP算法的精髓和高效之处全在这个辅助数组。

     比如这个例子，模式P和T匹配过程中，（a）中一个特定的位移 s 处，q = 5个字符已经匹配成功，但是第六个字符不匹配了，如果是朴素算法，位移s处无效，则接着到 s + 1处，但是明显的 s + 1 处是明显无效的，而如（b）图，s + 2前三个字符都可以匹配，所以很可能是匹配点。数组π记录的就是这些信息，比如对于P，上边的例子 π[5] = 3，则下一个可能的位移是s’= s + （q – π[q]），即s’= s + 2，也就是在匹配过程中，同时用π数组记录下一次可能匹配位置的信息。

     上边例子，完整π数组的值：

     如果你能看懂上边的例子，那么代码就极好理解了，KMP算法伪代码，其中 COMPUTE-PREFIX-FUNCTION 过程是预处理来计算π数组的：

KMP-MATCHER(T, P)
1 n ← length[T]
2 m ← length[P]
3 π ← COMPUTE-PREFIX-FUNCTION(P)
4 q ← 0                          ▹Number of characters matched.
5 for i ← 1 to n                 ▹Scan the text from left to right.
6      do while q > 0 and P[q + 1] ≠ T[i]
7             do q ← π[q]    ▹Next character does not match.
8         if P[q + 1] = T[i]
9            then q ← q + 1      ▹Next character matches.
10         if q = m                    ▹Is all of P matched?
11            then print "Pattern occurs with shift" i – m
12                 q ← π[q]    ▹Look for the next match.
COMPUTE-PREFIX-FUNCTION(P)
1 m ← length[P]
2 π[1] ← 0
3 k ← 0
4 for q ← 2 to m
5      do while k > 0 and P[k + 1] ≠ P[q]
6             do k ← π[k]
7         if P[k + 1] = P[q]
8            then k ← k + 1
9         π[q] ← k
10 return π

KMP代码实现：

[cpp] view plaincopy

1. /* 
2. 运行结果： 
3. ———————————————— 
4. 匹配位置: 1 
5. 匹配位置: 12 
6. */  
7.    
8. #include<iostream>  
9. #include<cstdio>  
10. #include<cstring>  
11. #include<string>  
12. using namespace std;  
13.    
14. //伪代码中的fail数组，用fail来表示  
15. int fail[1000];  
16.    
17. //预处理fail数组  
18. void ComputePrefixFunction(char *P) {  
19.     int m = strlen(P);  
20.     memset(fail, 0, sizeof(fail));  
21.     fail[0] = 0;  
22.     int k = 0;  
23.     for (int i = 2; i <= m; i++) {  
24.         while (k > 0 && P[k] != P[i - 1]) {  
25.             k = fail[k - 1];  
26.         }  
27.         if (P[k] == P[i - 1]) {  
28.             k = k + 1;  
29.         }  
30.         fail[i - 1] = k;  
31.     }  
32. }  
33.    
34. void KMPMatcher(char *T, char *P) {  
35.     int n = strlen(T);  
36.     int m = strlen(P);  
37.    
38.     int q = 0;  
39.     for (int i = 1; i <= n; i++) {  
40.         while (q > 0 && P[q] != T[i - 1]) {  
41.             q = fail[q - 1];  
42.         }  
43.    
44.         if(P[q] == T[i - 1]) {  
45.             q = q + 1;  
46.         }  
47.    
48.         if(q == m) {  
49.             printf("匹配位置: %d\n", i - m + 1);  
50.             q = fail[q - 1];  
51.         }  
52.     }  
53. }  
54.    
55. int main() {  
56.     KMPMatcher("123451233211234561234", "12345");  
57.     return 0;  
58. }  

 关于KMP算法，Matrix67的这篇文章不能错过KMP算法详解。

三、字典树

     字典树：又称为 Trie ，是一种用于快速检索的多叉树结构。如英文字母的字典树是一个26叉树。数字的字典树是一个10叉树。字典树的基本功能是用来查询某个单词在所有单词中出现次数的一种数据结构，它的插入和查询复杂度都为O(len)，Len为单词（前缀）长度，但是它的空间复杂度却非常高，如果字符集是26个字母，那每个节点的度就有26个，典型的以空间换时间结构。

     相比较Rabin-Karp算法和KMP算法主要解决，少量长字符之间匹配问题。字典树主要用于解决大量短字符之间匹配问题。

     特别地：和二叉查找树不同，在Trie树中，每个结点上并非存储一个元素。 在 Trie 树中查找一个关键字的时间和树中包含的结点数无关，而取决于组成关键字的字符数。HH师兄讲字典树时的一个例子，用she，he，his，hers 构成一棵字典树：

    

MatRush博客摘录：

字典树特点：

①利用串的公共前缀->节约内存。

②根结点(root)不包含任何字母。

③其余结点仅包含一个字母(非元素)。

④每个结点的子结点包含字母不同。

字典树查找过程：

①在Trie树上进行检索总是始于根结点。

②取得要查找关键词的第一个字母，并根据该字母选择对应的子树并转到该子树继续进行检索。

③在相应的子树上，取得要查找关键词的第二个字母，并进一步选择对应的子树进行检索。

④在某个结点处，关键词的所有字母已被取出，则读取附在该结点上的信息，即完成查找。

    假如用包含26个字母的字符构造字典树，那么每个结点都最多有26个分支，匹配某个单词时，每个字符在字典树中对应一层，这样可以非常快速的查找，因为根据字符对应分支查找就可以了。字典树主要的时间花在预处理构造字典树上，设node为实际使用的结点数目，建树O(node * 26)，每次查询是O(length)，空间复杂度O(node * 26)。

字典树模板：（初学时，看的是 MatRush 的博文，所以模板源于此）

[cpp] view plaincopy

1. //HDU 1251 代码，字典树模板  
2. #include<iostream>  
3. #include<cstdio>  
4. #include<cstring>  
5. #include<string>  
6. #include<cmath>  
7. #include<algorithm>  
8. using namespace std;  
9.    
10. const int MAXN = 100010, MAXM = 11, KIND = 26;  
11. //小写字母->26 ，大小混写->52，大小写+数字->62  
12. int m;  
13. struct node {  
14.     char* s;  
15.     int prefix;  
16.     bool isword;  
17.     node* next[KIND];  
18.     void init() {  
19.         s = NULL;  
20.         prefix = 0;//前缀  
21.         isword = false;  
22.         memset(next, 0, sizeof(next));  
23.     }  
24. }a[MAXN*MAXM], *root;//根  
25.    
26. void insert(node *root, char *str) {//插入  
27.     node *p = root;  
28.     for (int i = 0; str[i]; i++) {  
29.         int x = str[i] - 'a';  
30.         p->s = str + i;  
31.         if (p->next[x] == NULL) {  
32.             a[m].init();  
33.             p->next[x] = &a[m++];  
34.         }  
35.         p = p->next[x];  
36.         p->prefix++;  
37.     }  
38.     p->isword = true;  
39. }  
40.    
41. bool del(node *root, char *str) {//删除  
42.     node *p = root;  
43.     for (int i = 0; str[i]; i++) {  
44.         int x = str[i] - 'a';  
45.         if (p->next[x] == NULL) {  
46.             return false;  
47.         }  
48.         p = p->next[x];  
49.     }//for(i)  
50.     if (p->isword) {  
51.         p->isword = false;  
52.     } else {  
53.         return false;  
54.     }  
55.     return true;  
56. }  
57.    
58. bool search(node *root, char* str) {//查找  
59.     node* p = root;  
60.     for (int i = 0; str[i]; i++) {  
61.         int x = str[i] - 'a';  
62.         if (p->next[x] == NULL) {  
63.             return false;  
64.         }  
65.         p = p->next[x];  
66.     }//for(i)  
67.     return p->isword;  
68. }  
69.    
70. int count(node *root, char *str) {//统计后缀  
71.     node *p = root;  
72.     for (int i = 0; str[i]; i++) {  
73.         int x = str[i] - 'a';  
74.         if (p->next[x] == NULL) {  
75.             return 0;  
76.         }  
77.         p = p->next[x];  
78.     }//for(i)  
79.     return p->prefix;  
80. }  
81.    
82. int main() {  
83.     m = 0;  
84.     a[m].init();  
85.     root = &a[m++];  
86.     char str[MAXM];  
87.    
88.     while (gets(str), strcmp(str, "")) {  
89.         insert(root, str);  
90.     }  
91.    
92.     while (gets(str)) {  
93.         printf("%d\n", count(root,str));  
94.     }  
95. }  

四、AC自动机

     首先简要介绍一下AC自动机：Aho-Corasick automation，该算法在1975年产生于贝尔实验室，是著名的多模匹配算法之一。一个常见的例子就是给出n个单词，再给出一段包含 m 个字符的文章，让你找出有多少个单词在文章里出现过。要搞懂AC自动机，先得有模式树（字典树）Trie 和 KMP模式匹配算法 的基础知识。AC自动机算法分为 3 步：构造一棵Trie树，构造失败指针和模式匹配过程。

     如果你对 KMP 算法和了解的话，应该知道 KMP算法 中的 next 函数（shift 函数或者 fail 函数，即上文的π）是干什么用的。KMP 中我们用两个指针 i 和 j 分别表示，A[ i – j + 1……i ] 与 B[1…….j ] 完全相等。也就是说，i 是不断增加的，随着 i 的增加 j 相应地变化，且 j 满足以 A[i] 结尾的长度为 j 的字符串正好匹配B串的前 j 个字符，当 A [ i + 1] ≠ B [ j + 1]，KMP 的策略是调整j的位置（减小 j 值）使得A [ i – j + 1……i ]与 B[1……j ] 保持匹配且新的 B [ j + 1 ] 恰好与 A [ i + 1 ]匹配，而 next 函数恰恰记录了这个 j 应该调整到的位置。同样AC自动机的失败指针具有同样的功能，也就是说当我们的模式串在Tire上进行匹配时，如果与当前节点的关键字不能继续匹配的时候，就应该去当前节点的失败指针所指向的节点继续进行匹配。

     这里有一个帖子讲的非常详细，AC自动机，此贴足矣：AC自动机算法详解，AC自动机的关键概念是fail指针，上边那个例子的fail指针。

     PS：AC自动机常用来，解决少量长字符匹配大量短字符的问题（常常做辅助以解决更难的问题）

     HDU 2222  Keywords Search，给你10000个单词(每个单词长度不大于50,由小写字母组成),现在给你一个长句子(长度1000000)，问出现了多少单词表里的单词，AC自动机算法练习题，实现代码：

[cpp] view plaincopy

1. #include<iostream>  
2. #include<cstdio>  
3. #include<cstring>  
4. #include<string>  
5. #include<cmath>  
6. #include<algorithm>  
7. using namespace std;  
8. #define MAXN 10001  
9. #define MAXM 51  
10. #define KIND 26  
11.    
12. struct node {  
13.     int prefix;  
14.     node *fail;  
15.     node *next[26];  
16.     void init() {  
17.         prefix = 0;  
18.         fail = NULL;  
19.         memset(next, 0, sizeof(next));  
20.     }  
21. }*que[MAXN * MAXM], trie[MAXN * MAXM],  *root;  
22.    
23. int cnt;  
24. char keyword[MAXM];  
25. char str[MAXN * 2];  
26.    
27. void Insert(node *root, char *str) {  
28.     node *ptr = root;  
29.     for (int i = 0; str[i]; i++) {  
30.         int x = str[i] - 'a';  
31.         if (ptr->next[x] == NULL) {  
32.             trie[cnt].init();  
33.             ptr->next[x] = &trie[cnt++];  
34.         }  
35.         ptr = ptr->next[x];  
36.     }  
37.     ptr->prefix++;  
38. }//insert  
39.    
40. void Build(node *root) {  
41.     int head = 0, tail = 0;  
42.     root->fail = NULL;  
43.     que[head++] = root;  
44.     while (head != tail) {  
45.         node *tmp = que[tail++];  
46.         node *ptr = NULL;  
47.         for (int i = 0; i < KIND; i++) {  
48.             if (tmp->next[i] != NULL) {  
49.                 if (tmp == root) {  
50.                     tmp->next[i]->fail = root;  
51.                 } else {  
52.                     ptr = tmp->fail;  
53.                     while (ptr != NULL) {  
54.                         if (ptr->next[i] != NULL) {  
55.                             tmp->next[i]->fail = ptr->next[i];  
56.                             break;  
57.                         }  
58.                         ptr = ptr->fail;  
59.                     }  
60.                     if (ptr == NULL) {  
61.                         tmp->next[i]->fail = root;  
62.                     }  
63.                 }//if_else  
64.                 que[head++] = tmp->next[i];  
65.             }//if  
66.         }//for(i)  
67.     }//while (head != tail)  
68. }//Build  
69.    
70. int Query(node *root, char *str) {  
71.     int ret = 0;  
72.     node *ptr = root;  
73.     for (int i = 0; str[i]; i++) {  
74.         int x = str[i] - 'a';  
75.         while (ptr->next[x] == NULL && ptr != root) {  
76.             ptr = ptr->fail;  
77.         }  
78.         ptr = ptr->next[x];  
79.         if (ptr == NULL) {  
80.             ptr = root;  
81.         }  
82.         node *tmp = ptr;  
83.         while (tmp != root && tmp->prefix != -1) {  
84.             ret += tmp->prefix;  
85.             tmp->prefix = -1;  
86.             tmp = tmp->fail;  
87.         }  
88.     }//for(i)  
89.     return ret;  
90. }  
91.    
92. int main() {  
93.     int cas, n;  
94.     scanf("%d", &cas);  
95.     while (cas--) {  
96.         // head = tail = 0;  
97.         cnt = 0;  
98.         trie[cnt].init();  
99.         root = &trie[cnt++];  
100.    
101.         scanf("%d%*c", &n);  
102.         while (n--) {  
103.             gets(keyword);  
104.             Insert(root, keyword);  
105.         }  
106.         Build(root);//构造自动机  
107.         scanf("%s", str);  
108.         printf("%d\n", Query(root, str));  
109.     }  
110.     return 0;  
111. }