字符串匹配—KMP算法

 来源 – http://blog.csdn.net/ebowtang/article/details/49129363

前言　　

　 KMP算法是一种改进的字符串匹配算法，由D.E.Knuth，J.H.Morris和V.R.Pratt同时发现，因此人们称它为克努特——莫里斯——普拉特操作（简称KMP算法）。KMP算法的关键是利用匹配失败后的信息（已经匹配的部分中的对称信息），尽量减少模式串（待搜索词）与文本串的匹配次数以达到快速匹配的目的。具体实现就是实现一个next()函数，该函数本身包含了模式串的局部匹配信息。
　

一，kmp算法的原理：

字符串匹配是计算机的基本任务之一。它所执行的任务就是在一个文本（较长的字符串）中查找是否包含着当前指定的模式字符串（较短的字符串），并找到其位置，这就是字符串匹配问题。
注：在算法导论里面待搜索的词叫“模式”字符串，并用P来表示，本文有的地方叫他“待搜索词”。如无特殊说明数组下标以0为起始。
举例来说，有一个长字符串”BBC ABCDAB ABCDABCDABDE”（即文本串），我想知道里面是否包含另一个模式字符串”ABCDABD”，它的位置在哪呢？

1，朴素匹配算法过程：

1）.

首先，长字符串”BBC ABCDAB ABCDABCDABDE”的第一个字符与搜索词”ABCDABD”的第一个字符，进行比较。因为B与A不匹配，所以搜索词后移一位。

2）.

因为B与A不匹配，搜索词再往后移。

3）.

就这样，直到长字符串有一个字符，与搜索词的第一个字符相同为止（准备开始位置不变搜索下一个字符）。

4）.

接着比较字符串和搜索词的下一个字符，还是相同。

5）.

但是后面的有可能是不完全匹配的，这时在长字符串中遇到一个字符与搜索词对应的字符不相同。

6）.

最自然的反应是，将搜索词整个后移一位，再从头逐个比较。这样做虽然可行，但是效率很差，因为你要把搜索位置BCD这一段又要重比一次，然而它的比较在直到了后面有“AB”与前面的“AB”对称的情况下是可以避免的，直到遇到”AB”才萌发新的可能使整个字符匹配的可能性。

2，KMP匹配算法过程：

1).

接着前面的匹配过程，现在来看：一个基本事实是，当空格与D不匹配时，你其实知道前面六个符”ABCDAB”已经匹配的部分。KMP算法的想法是，设法利用这个搜索词的子串（就是搜索词的某个前缀）的已知对称值，注意这里的对称非中心对称，而是基于搜索词的某一个前缀的对称信息，在不匹配的时候跳过一些不必要的位置来加速匹配速度，这样就提高了效率。

2).

怎么做到这一点呢（如何跳过不必要的位置在不匹配时）？可以针对搜索词，算出一张模式字符串的前缀函数表。这张表是如何产生的，后面再介绍，这里只要知道就可以了。

3).

已知空格与D不匹配时，前面六个字符”ABCDAB”是匹配的。查模式串的《前缀函数表》可知，其前缀（即ABCDAB）中的最后一个匹配字符B的位置对应的”部分匹配值”为2，因此按照下面的公式算出向后移动的位数（直接将前面的对称信息调到后面的对称位置，跳过一些不必要的位置）：

　　移动位数 = 已匹配的字符数 – 当前已匹配字符串的部分匹配值

因为 6 – 2 等于4，所以将搜索词向后移动4位（之所以移动4，是因为搜索词的已匹配的前缀串“ABCDAB”的部分匹配值为2，即有“AB”对称，因为当前已匹配字符串的“AB”始终要找到下一个“AB”的开始位置，而这个开始位置恰好就在本字符串中的后缀中，所以直接移动4，我们可以最大减少匹配次数）。

4).

因为空格与Ｃ不匹配，搜索词还要继续往后移。这时，已匹配的字符数为2（”AB”），对应的”部分匹配值”为0。所以，移动位数 = 2 – 0，结果为 2，于是将搜索词向后移2位。

5).

因为空格与A不匹配，继续后移一位。

6).

逐位比较，直到发现C与D不匹配。于是，移动位数 = 6 – 2，继续将搜索词向后移动4位。

7).

逐位比较，直到搜索词的最后一位，发现完全匹配，于是搜索完成。如果还要继续搜索（即找出全部匹配），移动位数 = 7 – 0，再将搜索词向后移动7位，这里就不再重复了。

3,关于前缀函数表

1）前缀和后缀

首先，要了解两个概念：”前缀”和”后缀”。 “前缀”指除了最后一个字符以外，一个字符串的全部头部组合；”后缀”指除了第一个字符以外，一个字符串的全部尾部组合。

2）.前缀函数表的产生

“前缀函数”的对称值（也叫部分匹配值）就是模式串的对应前缀中的”前缀”和”后缀”的最长的共有元素的长度（实质是最大对称程度）。以”ABCDABD”为例，

　　－　”A”的前缀和后缀都为空集，共有元素的长度为0；

　　－　”AB”的前缀为[A]，后缀为[B]，共有元素的长度为0；

　　－　”ABC”的前缀为[A, AB]，后缀为[BC, C]，共有元素的长度0；

　　－　”ABCD”的前缀为[A, AB, ABC]，后缀为[BCD, CD, D]，共有元素的长度为0；

　　－　”ABCDA”的前缀为[A, AB, ABC, ABCD]，后缀为[BCDA, CDA, DA, A]，共有元素为”A”，长度为1；

　　－　”ABCDAB”的前缀为[A, AB, ABC, ABCD, ABCDA]，后缀为[BCDAB, CDAB, DAB, AB, B]，共有元素为”AB”，长度为2（“AB”是其最大对称串，长度为2）；

　　－　”ABCDABD”的前缀为[A, AB, ABC, ABCD, ABCDA, ABCDAB]，后缀为[BCDABD, CDABD, DABD, ABD, BD, D]，共有元素的长度为0。

3）.前缀函数表的意义

A,首相要搞清楚的是它是模式字符串的所有前缀产生的一张表，保存的值表征了最大对称度，我们一般用next数组来保存其某个前缀的对称值，例如next[6]=2，代表的就是模式串的某个有6个字符的前缀“ABCDAB”，这个前缀的对称度就是2，即“AB”是对称的。

B,模式串的某前缀的对称值的实质是，有时候，搜索词已经部分匹配了（一定是某个前缀），其某个前缀（已经匹配部分）的头部和尾部会有重复。比如，”ABCDAB”之中前缀有”AB”，后缀也有”AB”，那么它的”前缀函数对称值”就是2（”AB”的长度,且“AB”是”ABCDAB”所有前缀和后缀中的最长公有元素）。搜索词移动的时候，第一个”AB”向后移动4位（字符串长度-部分匹配值），就可以来到第二个”AB”的位置，在这个新的位置我们跳过了不必要的比较位置，并且直接就有“AB”匹配。

二，前缀函数表实现原理

　　通过上文完全可以对kmp算法的原理有个清晰的了解，那么下一步就是编程实现了，其中最重要的就是如何根据待匹配的模式字符串求出其所有前缀函数表中的最大对称值，在下文中我们将其存储在next数组中。

1，编程策略：

1）、当前字符的前面所有字符的对称程度为0的时候，只要将当前字符与前面这个子串的第一个字符进行比较。这个很好理解啊，前面所有字符串的对称值都是0，说明都不对称了，如果多加了一个字符，要对称的话只能是当前字符和前面字符串的第一个字符对称。比如“ABCDA”这个里面”ABCD”的最大对称值是0，那么后面的A的对称程度只需要看它是不是等于前面字符串的第一个字符A相等，如果相等就增加1，如果不相等那就保持不变，显然还是为0。

 

2）、按照这个推理，我们就可以总结一个规律，不仅前面是0呀，如果前面字符串的的最大对称值是1（k），那么我们就把当前字符与前面字符串的第二（k）个字符即P[1]（P[k]）进行比较，因为前面的是1（k），说明前面的字符已经和第一（k）个字符相等了，如果这个又与第二（k+1）个相等了，说明对称程度就是2（k+1）了。有两（k+1）个字符对称了。比如上面“ABCDA”的最大对称值是1，说明它只和第一个A对称了，接着我们就把下一个字符“B”与P[1]（即第二个字符）比较，又相等，自然对称程度就累加了，就是2了。

但是如果不相等呢？那么这个对称值显然要减少，并且我们只能到前面去寻找对称值，而在找的过程我们同时也利用前缀函数表快速搜索找到与当前字符匹配的位置。比如假设是“（AGCTAGC）（AGCTAGC）T”（请无视字符串中的括号，只为方便看出对称），显然最后一个T的前一个位置的对称度是7,说明T的前一个位置的7个字符的后缀必与7个字符的前缀相等，然而T!=P[7]，说明T位置的对称度只能是比7小的长度的前缀，所以递减k值，递减为多少呢？当前字符前一个位置的对称度为k=next[13]=7，显然必须以7为基准减少，即在前缀长度为7以内的范围重新寻找以T结尾的前缀，所以k=next[6]，再接着判断是否相等,

 

3）、按照上面的推理，我们总是在找当前字符P[q]（q为遍历到的位置下标，见下面程序）通过其前一个位置的对称值判断是否与P[k]相等，如果相等，那么加，如果不相等，那么就减少k值，重新寻找与与P[q]相等的元素位置

2，参考代码：

 1 void MakeNext(const char P[],int next[])
 2 {
 3     int k;//k:最大对称长度
 4     int m = strlen(P);//模版字符串长度
 5     next[0] = 0;//模版字符串的第一个字符的最大对称值必为0
 6     for (int q = 1,k = 0; q < m; ++q)//for循环，从第二个字符开始，依次计算每一个字符对应的next值
 7     {//在前一个位置的k不为0，但是却不相等，那么减少k，重新寻找与P[q]相等的位置，让下面的if来增加k
 8         while(k > 0 && P[q] != P[k])//
 9             k = next[k-1];          //while循环是整段代码的精髓所在，
10         if (P[q] == P[k])//如果相等，那么最大相同前后缀长度加1
11             k++;//增加k的唯一方式
12         next[q] = k;
13     }
14 } 

3，代码解释：

现在我着重讲解一下while循环所做的工作：

1. 　　已知前一个位置的最大相同前后缀长度为k，且k>0，即P[0]···P[k-1]；
2. 　　此时比较第k项P[k]与P[q],如图1所示
3. 　　如果P[K]等于P[q]，那么很简单跳出while循环;
4. 　　如果不等呢？那么我们应该利用已经得到的next[0]···next[k-1]来求P[0]···P[k-1]这个前缀中最大相同前后缀。为什么要求P[0]···P[k-1]的最大相同前后缀呢？为什么呢？ 原因在于P[k]已经和P[q]失配了，而且P[q-k] ··· P[q-1]又与P[0] ···P[k-1]相同，看来P[0]···P[k-1]这么长的子串是用不了了，那么我要找个同样也是P[0]打头、P[k-1]结尾的子串即P[0]···P[j-1](j==next[k-1])，看看它的下一项P[j]是否能和P[q]匹配。如图2所示

附完整代码：

[cpp] 
view plain
 copy  

1. #include “vector”  
2. #include “string”  
3. #include <iostream>  
4. #include “algorithm”  
5.   
6. using namespace std;  
7.   
8. //计算模式P的部分匹配值，保存在next数组中    
9. void MakeNext(const string &P, vector<int> &next)  
10. {  
11.     int q,k;//k记录所有前缀的对称值    
12.     int m = P.size();//模式字符串的长度    
13.     next[0] = 0;//首字符的对称值肯定为0    
14.     for (q = 1, k = 0; q < m; ++q)//计算每一个位置的对称值    
15.     {  
16.         //k总是用来记录上一个前缀的最大对称值    
17.         while (k > 0 && P[q] != P[k])  
18.             k = next[k – 1];//k将循环递减，值得注意的是next[k]<k总是成立    
19.         if (P[q] == P[k])  
20.             k++;//增加k的唯一方法    
21.         next[q] = k;//获取最终值    
22.     }  
23. }  
24.   
25.   
26. void KmpMatch(const string &T, const string &P, vector<int> &next)  
27. {  
28.     int n, m;  
29.     n = T.size();  
30.     m = P.size();  
31.     MakeNext(P, next);  
32.     for (int i = 0, q = 0; i < n; ++i)  
33.     {  
34.         while (q > 0 && P[q] != T[i])  
35.             q = next[q – 1];  
36.         if (P[q] == T[i])  
37.             q++;  
38.         if (q == m)  
39.         {  
40.             cout << “模式文本的偏移为：” << (i – m + 1) << endl;  
41.             q = next[q – 1];//寻找下一个匹配  
42.         }  
43.     }  
44. }  
45.   
46. int main()  
47. {  
48.     system(“color 0A”);  
49.     vector<int> next(20,0);//保存待搜索字符串的部分匹配表（所有前缀函数的对称值）  
50.     string T = “xyxababcaxxxababca”;//文本  
51.     string P = “ababca”;//待搜索字符串  
52.     cout <<“文本字符串：”<< T << endl;  
53.     cout <<“模式字符串：”<< P << endl;  
54.     KmpMatch(T, P, next);  
55.     cout << “模式字符串的前缀函数表：”<< endl;  
56.     for (int i = 0; i < P.size(); i++)  
57.         cout<< next[i];  
58.     cout << endl;  
59.     system(“pause”);  
60.     return 0;  
61. }  

三，实践KMP算法：

String Matching

题目描述：

    Finding all occurrences of a pattern in a text is a problem that arises frequently in text-editing programs. 
    Typically,the text is a document being edited,and the pattern searched for is a particular word supplied by the user.  
    We assume that the text is an array T[1..n] of length n and that the pattern is an array P[1..m] of length m<=n.We further assume that the elements of P and  T are all alphabets(∑={a,b…,z}).The character arrays P and T are often called strings of characters.  
    We say that pattern P occurs with shift s in the text T if 0<=s<=n and T[s+1..s+m] = P[1..m](that is if T[s+j]=P[j],for 1<=j<=m).  
    If P occurs with shift s in T,then we call s a valid shift;otherwise,we calls a invalid shift. 
    Your task is to calculate the number of vald shifts for the given text T and p attern P.

输入：

   For each case, there are two strings T and P on a line,separated by a single space.You may assume both the length of T and P will not exceed 10^6. 

输出：

    You should output a number on a separate line,which indicates the number of valid shifts for the given text T and pattern P.

样例输入：

abababab abab

样例输出：

3

[html] 
view plain
 copy  

1. #include <iomanip>//小数点精确  
2. #include <cstdio>    
3. #include <cstdlib>    
4. #include “vector”  
5. #include “string”  
6. #include “algorithm”  
7. #include <iostream>  
8. #include “stack”  
9. #include “math.h”    
10.    
11. using namespace std;  
12.    
13. //计算模式P的部分匹配值，保存在next数组中      
14. void MakeNext(const string &P, vector<int> &next)  
15. {  
16.     int q, k;//k记录所有前缀的对称值      
17.     int m = P.size();//模式字符串的长度      
18.     next[0] = 0;//首字符的对称值肯定为0      
19.     for (q = 1, k = 0; q < m; ++q)//计算每一个位置的对称值      
20.     {  
21.         //k总是用来记录上一个前缀的最大对称值      
22.         while (k > 0 && P[q] != P[k])  
23.             k = next[k – 1];//k将循环递减，值得注意的是next[k]<k总是成立      
24.         if (P[q] == P[k])  
25.             k++;//增加k的唯一方法      
26.         next[q] = k;//获取最终值      
27.     }  
28. }  
29.    
30.    
31. int KmpMatch(const string &T, const string &P, vector<int> &next)  
32. {  
33.     int n = 0, m = 0, count = 0;  
34.     n = T.size();  
35.     m = P.size();  
36.     MakeNext(P, next);  
37.     for (int i = 0, q = 0; i < n; ++i)  
38.     {  
39.         while (q > 0 && P[q] != T[i])  
40.             q = next[q – 1];  
41.         if (P[q] == T[i])  
42.             q++;  
43.         if (q == m)  
44.         {  
45.             q = next[q – 1];//寻找下一个匹配    
46.             count++;  
47.         }  
48.     }  
49.     return count;  
50. }  
51.    
52. int main()  
53. {  
54.     string T;//文本    
55.     string P;//待搜索字符串   
56.     vector<int> next(200, 0);//保存待搜索字符串的部分匹配表（所有前缀函数的对称值）    
57.     while (cin >> T >> P)  
58.     {//本题为kmp算法的简单应用  
59.         cout << KmpMatch(T, P, next) << endl;  
60.     }  
61.            
62.     return 0;  
63. }  
64. /**************************************************************  
65.     Problem: 1094  
66.     User: EbowTang  
67.     Language: C++  
68.     Result: Accepted  
69.     Time:160 ms  
70.     Memory:3052 kb  
71. ****************************************************************/  

参考资源：

【1】网友，c_cloud，《KMP，深入讲解next数组的求解》，博客地址，http://www.cnblogs.com/c-cloud/p/3224788.html
【2】网友，yearn520，《KMP算法的前缀next数组最通俗的解释》，博客地址，http://blog.csdn.net/yearn520/article/details/6729426
【3】《算法导论》，第三十二章，字符串匹配
【4】网友，jBoxer，《The Knuth-Morris-Pratt Algorithm in my own words》，博客地址，http://jakeboxer.com/blog/2009/12/13/the-knuth-morris-pratt-algorithm-in-my-own-words/

【5】九度OJ，http://ac.jobdu.com/problemset.php?page=2