KMP

    字符串匹配的算法当属KMP最为著名了，人人皆知，但是KMP算法是如何做到高效率字符串匹配的呢？

    我们首先来看看一般的暴力的字符串匹配算法，对于串s和模式串pattern，依次枚举s中的每一个字符作为起点与pattern尝试进行匹配，直到遇到不匹配的字符的时候，取下一个s中的字符作为起点与模式串pattern重新进行匹配。我们知道这样的时间复杂度是O(n*m)的，显然效率很不好。

    从上面暴力匹配的过程我们可以知道，当暴力进行匹配的时候，遇到不匹配的字符，不一定要从s的下一个字符重新与模式串进行匹配，那么我们如何做到这一点呢？这就要用到KMP中神奇的next数组了。

    next数组记录的是模式串的特征，从而当匹配不成功的时候，我们不一定完全对s的下一个字符与模式串从头开始匹配。于是next[i]表示当i与s中的某个串匹配不成功的时候，我们应该用第next[i]的字符与s中的当前位进行匹配。也就是说模式串pattern的子串[pattern[0], pattern[next[k]-1]]与子串[pattern[k-next[k]], pattern[k-1]]完全相同。

    我们为什么能将next数组用在与s的匹配过程中呢？因为当s[i]与patter[k]不匹配的时候，说明pattern的子串[pattern[0], pattern[k-1]]已经与s的子串[s[i-k], s[i-1]]完全匹配了，而这个时候借助next数组，我们知道如果pattern有一个前缀与s[0, i-1]的某一个后缀完全相同，我们就应该将前缀的最后一个字符的后面一个字符同s[i]进行尝试匹配。这样子大大的减少了没有作用的盲目匹配尝试。

    我们可以预见KMP算法的均摊复杂度是O(n+m)，为什么呢？因为你的s串是不会回退的，因此最多访问了n次，而模式串pattern在每一次匹配中的走动均摊下来近似为O(m)的，因此总的复杂度为O(n+m)。

    下面贴上我的KMP算法的模板，如果模式串在s中出现，则返回子串第一次出现的位置，否则返回-1。

[cpp] view plaincopy

1. #include <iostream>  
2. #include <cstdlib>  
3. #include <cstdio>  
4. #include <cstring>  
5. using namespace std;  
6. const int kMax1 = 1000010;  
7. const int kMax2 = 10010;  
8. char g_pattern[kMax2];  
9. char g_s[kMax1];  
10. int g_next[kMax2];  
11.   
12. void GetNext(int n)  
13. {  
14.     memset(g_next, -1, sizeof(g_next));  
15.     g_next[0] = -1;  
16.     g_next[1] = 0;  
17.     int k = 0;  
18.     int i = 1;  
19.     while(i<(n-1))  
20.     {  
21.         //printf("i=%d, k=%d\n", i, k);  
22.         if(k == -1 || g_pattern[k] == g_pattern[i])  
23.         {  
24.             ++i; ++k;  
25.             g_next[i] = k;  
26.         }  
27.         else  
28.             k = g_next[k];  
29.     }  
30. }  
31.   
32. int KMP(int n)  
33. {  
34.     int ans = -1;  
35.     int i = 0;  
36.     int j = 0;  
37.     int pattern_len = strlen(g_pattern);  
38.     while(i < n)  
39.     {  
40.         if(j == -1 || g_s[i] == g_pattern[j])  
41.         {  
42.             ++i; ++j;  
43.         }  
44.         else  
45.             j = g_next[j];  
46.         if(j == pattern_len)  
47.         {  
48.             ans = i - pattern_len;  
49.             break;  
50.         }  
51.     }  
52.     return ans;  
53. }