KMP

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

举例来说，有一个字符串"BBC ABCDAB ABCDABCDABDE"，我想知道，里面是否包含另一个字符串"ABCDABD"？

1.

 

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

2.

 

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

3.

 

就这样，直到字符串有一个字符，与搜索词的第一个字符相同为止。

4.

 

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

5.

 

直到字符串有一个字符，与搜索词对应的字符不相同为止。

6.

 

这时，最自然的反应是，将搜索词整个后移一位，再从头逐个比较。这样做虽然可行，但是效率很差，因为你要把"搜索位置"移到已经比较过的位置，重比一遍。

7.

 

一个基本事实是，当空格与D不匹配时，你其实知道前面六个字符是"ABCDAB"。KMP算法的想法是，设法利用这个已知信息，不要把"搜索位置"移回已经比较过的位置，继续把它向后移，这样就提高了效率。

8.

 

怎么做到这一点呢？可以针对搜索词，算出一张《部分匹配表》（Partial MatchTable）。这张表是如何产生的，后面再介绍，这里只要会用就可以了。

9.

 

已知空格与D不匹配时，前面六个字符"ABCDAB"是匹配的。查表可知，最后一个匹配字符B对应的"部分匹配值"为2，因此按照下面的公式算出向后移动的位数：

　　移动位数 = 已匹配的字符数 - 对应的部分匹配值

因为 6 - 2 等于4，所以将搜索词向后移动4位。

10.

 

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

11.

 

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

12.

 

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

13.

 

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

14.

 

下面介绍《部分匹配表》是如何产生的。

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

15.

 

"部分匹配值"就是"前缀"和"后缀"的最长的共有元素的长度。以"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；

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

16.

 

"部分匹配"的实质是，有时候，字符串头部和尾部会有重复。比如，"ABCDAB"之中有两个"AB"，那么它的"部分匹配值"就是2（"AB"的长度）。搜索词移动的时候，第一个"AB"向后移动4位（字符串长度-部分匹配值），就可以来到第二个"AB"的位置。

我的理解：

要避免常规方法那样一个字符一个字符地往后移动，就是要我们找出不必要的移动，就是直接跳到可能存在相同子串的地方然后再往后寻找，比如上例中主串BBC ABCDAB ABCDABCDABDE,子串ABCDABD, 我们“肉眼”一看，（可能有的人呢...一眼就找到了，那你牛*啊，我不信长度几千你也能一眼瞄......）首先直接跳过BBC，找到第一个A开头的那一串，发现不行，继续找，此时我们的视线不是往后移一位移到B那里，而是找到第二个A开头那一串，发现也不行，我们跳过中间的B，（因为聪明的大脑告诉我们肯定要找以A开头的  哈哈）找第三个A开头的..不行..找第四个A开头的...哇~发现找到了，那这就是我们“肉眼”找子串的过程，那如何让计算机也像我们一样聪明呢，也按照这样“机智”的方法找呢？难点就在于如何让程序知道：在上一次寻找失败后，下一步要往后跳几个字符。这里就体现了“机智”，而不是传统方法的暴力查找。那如何知道知道跳几步呢？

首先进行的就是对子串进行一个预处理，求出它的匹配值，即子串前缀和后缀的最大公共子串的长度。就是next数组，解决了这个跳几步的问题，接下来就是要知道什么时候跳了，这比求匹配值好想的多，不匹配就往后跳呗。

示例代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<queue>
#include<set>
#include<map>
#include<vector>
#include<stack>
using namespace std;
struct str{
    char s[100];   //字符串
    int length;   //长度
}t,p; //主串和子串
int next[102];   //子串做预处理后得到的
void getnext(struct str p,int next[]){  //预处理  得出匹配值 即要偏移的距离存入next数组中
    int i=0,j=-1;
    next[0]=-1;
    while(i<p.length){
        if(j==-1||p.s[i]==p.s[j]){ 
            i++;
            j++;
            next[i]=j;
        }
        else
            j=next[j];
    }
//    for(i=0;i<p.length;i++)
//        printf("%d ",next[i]);
//    printf("\n");
}
int kmp(struct str t,struct str p,int next[]){
    int i=0,j=0;
    while(i<t.length&&j<p.length){
        if(j==-1||t.s[i]==p.s[j]){
            i++;
            j++;
        }
        else
            j=next[j];
    }
    if(j==p.length)return i-p.length;
    return -1;
}
int main()
{
    scanf("%s",t.s);
    t.length=strlen(t.s);
    scanf("%s",p.s);
    p.length=strlen(p.s);
    getnext(p,next);
    printf("%d\n",kmp(t,p,next));
    return 0;
}