谈谈KMP算法

        KMP算法是优秀高效的字符串匹配算法，典型用法是查询一个字符串(通常称其为模式串)是否是另一个字符串（通常称其为目标串）的字串，是的话返回第一次出现的位置。当然，如果能深刻理解KMP算法的思想和原理，还可以用它解决一些其他的字符串问题。

       网上相关的介绍有许多，这里我主要记录加介绍其中一些难理解的部分。

      核心思想：利用模式串的自匹配信息（next[]数组）

       朴素的字符串比较算法缺点在于一旦比较到某个字符不匹配，目标串和模式串都要同时回溯，但其实这样会造成许多重复比较，而KMP算法正是利用模式串的自匹配信息，去掉这些冗余的比较。例：

       

       当S[5]和T[5]不匹配时，朴素算法的做法是将S回溯到S[1]，T回溯到T[0]，再开始比较，而KMP算法则是S串不回溯，让S[5]和T[2]进行比较。因为S[1]==T[1]，而T[1]!=T[0]，因此必然S[1]!=T[0]，而朴素算法还要比较这一步，显然是没必要的。

       那么如何知道当不匹配时该如何移动模式串呢？主要就是靠next[]数组。这里我们可以看到，T[5]之前的字串"abcab"它的前缀和后缀最长公共部分是"ab"，其长度是2而且T[2]!=T[5]，那么next[5]=2。

       简单说，next[]数组里存的其实就是对应位置前 ，前后缀的最长公共部分的长度。这样，当那个位置不匹配时，目标串不动，可以直接把模式串前缀的位置“拉”到后缀的位置，因为它们是相同（预处理部分已求出），所以不需要再次比较。接着继续与目标串进行比较即可。体现在上面这个例子就是：当S[5]和T[5]不匹配，而T[5]之前的相同前后缀是"ab"，就直接把T[0]、T[1]“拉”到T[3]、T[4]的位置，显然T[0]==S[3]、T[1]==S[4]，接着比较T[2]与S[5]就行了。

       那么该如何求next[]数组呢？其实那就是求模式串的一个自匹配过程（让模式串的字串与模式串本身进行匹配），既对模式串设两个下标，一个下标表示扫描模式串本身，一个表示模式串字串，因此求next[]数组的代码与跟目标串和模式串的匹配代码相似。

#include <iostream>
#include <vector>
#include <ctime>
#include <algorithm>
#include <cstdlib>
#include <cstring>
using namespace std;
const int N  = 1e3+1;
int next1[N];
void getNext(const char *T)
{
    int j=0,k=-1;// j下标表示模式串本身（也是求相同前后缀过程中的后缀终止部分）k代表模式串字串（前缀终止部分）
                 // 任何时候，都有T[0...k-1]与S[j-k...j-1]的相同，表示求解过程中对应的相同前后缀
    next1[0]=-1;
    while(T[j]) {
        if (k==-1 || T[j]==T[k]) {
            j++; k++;
            if (T[j]==T[k]) next1[j]=next1[k];//KMP算法的优化部分，若T[j]与目标串不匹配时，因为T[j]==T[k]，而若还让next1[j]=k，则匹配过程中模式串会回溯到k的位置，而T[k]显然还是不匹配，因此因采用next[k]处的跳转策略,既用T[next[k] ]去继续匹配；
            else next1[j]=k;
        }
        else k=next1[k];
    }
//    for(int  i=0;i<j;i++)  //显示
//   {
//        cout<<next1[i]<<" ";
//   }
//   cout<<endl;
}
//abcdabcacab
int slove(const char* S,const char* T)
{
    int i=0,j=0;
    int len=strlen(T);
    while(S[i]) {
        if (S[i]==T[j]) {
            i++,j++;
            if (!T[j]) return i-len;
        }
        else {
            if (next1[j]==-1) i++,j=0;
            else if (next1[j]==0) j=0;
            else j=next1[j];
        }
    }
    return -1;
}

int main()
{
    int n;
      char a[N],b[N];
    while(cin>>a>>b)
    {

        getNext(b);
        printf("%d",slove(a,b));
    }
}



/*
abcdabcacab
abca


dfkdkdldklsdfkdfddkfjsdjfie
fddkf;


*/

附：

串的模式值next[n]含义：

定义：

（1）next[0]= -1  意义：任何串的第一个字符的模式值规定为-1。

（2）next[j]= -1   意义：T[j] == T[0]，且j的前面的1—k个字符与开头的1—k个字符不等（或者相等但T[k]==T[j] （1≤k<j））。

        如：T=”abCabCad” 则 next[6]=-1，因T[3]=T[6]

（3）next[j]=k    意义：模式串T中下标为j的字符，如果j的前面k个字符与开头的k个字符相等，且T[j] != T[k] （1≤k<j）。 

          即T[0]T[1]T[2]。。。T[k-1]==T[j-k]T[j-k+1]T[j-k+2]…T[j-1]且T[j] != T[k].（1≤k<j）;

 (4) next[j]=0   意义：不存在j的前面的1—k个字符与开头的1—k个字符相等，且T[j] != T[0]

 

举例：

01）求T=“abcac”的模式函数的值。

     next[0]= -1  根据（1）

     next[1]=0   根据 (4)   因（3）有1<=k<j;不能说，j=1,T[j-1]==T[0]

     next[2]=0   根据 (4)   因（3）有1<=k<j;（T[0]=a）!=（T[1]=b）

     next[3]= -1  根据 (2)

     next[4]=1   根据 (3)  T[0]=T[3] 且 T[1]=T[4]

    即   

下标	0	1	2	3	4
T	a	b	c	a	c
next	-1	0	0	-1	1

若T=“abcab”将是这样：

下标	0	1	2	3	4
T	a	b	c	a	b
next	-1	0	0	-1	0

为什么T[0]==T[3],还会有next[4]=0呢, 因为T[1]==T[4], 根据 (3)” 且T[j] != T[k]”被划入（4）。

02）来个复杂点的，求T=”ababcaabc” 的模式函数的值。

next[0]= -1    根据（1）

         next[1]=0    根据(4)

         next[2]=-1   根据 (2)

next[3]=0   根据 (3) 虽T[0]=T[2] 但T[1]=T[3] 被划入（4）

next[4]=2   根据 (3) T[0]T[1]=T[2]T[3] 且T[2] !=T[4]

next[5]=-1  根据 (2) 

next[6]=1   根据 (3) T[0]=T[5] 且T[1]!=T[6]

next[7]=0   根据 (3) 虽T[0]=T[6] 但T[1]=T[7] 被划入（4）

next[8]=2   根据 (3) T[0]T[1]=T[6]T[7] 且T[2] !=T[8]

 即

下标	0	1	2	3	4	5	6	7	8
T	a	b	a	b	c	a	a	b	c
next	-1	0	-1	0	2	-1	1	0	2

只要理解了next[3]=0，而不是=1，next[6]=1，而不是= -1，next[8]=2，而不是= 0，其他的好象都容易理解。

03)   来个特殊的，求 T=”abCabCad” 的模式函数的值。

下标	0	1	2	3	4	5	6	7
T	a	b	C	a	b	C	a	d
next	-1	0	0	-1	0	0	-1	4

         

next[5]= 0  根据 (3) 虽T[0]T[1]=T[3]T[4],但T[2]==T[5]

next[6]= -1  根据 (2) 虽前面有abC=abC,但T[3]==T[6]

next[7]=4   根据 (3) 前面有abCa=abCa,且 T[4]!=T[7]

若T[4]==T[7]，即T=” adCadCad”,那么将是这样：next[7]=0, 而不是= 4,因为T[4]==T[7].

下标	0	1	2	3	4	5	6	7
T	a	d	C	a	d	C	a	d
next	-1	0	0	-1	0	0	-1	0

 

如果你觉得有点懂了，那么

练习：求T=”AAAAAAAAAAB” 的模式函数值，并用后面的求模式函数值函数验证。

 

意义：

 next 函数值究竟是什么含义，前面说过一些，这里总结。

设在字符串S中查找模式串T，若S[m]!=T[n],那么，取T[n]的模式函数值next[n],

1.       next[n]=  -1 表示S[m]和T[0]间接比较过了，不相等，下一次比较 S[m+1] 和T[0]

2.       next[n]=0 表示比较过程中产生了不相等，下一次比较 S[m] 和T[0]。

3.       next[n]= k >0 但k<n, 表示,S[m]的前k个字符与T中的开始k个字符已经间接比较相等了，下一次比较S[m]和T[k]相等吗？

4.       其他值，不可能。