完全掌握KMP算法思想

文档下载页面http://download.csdn.net/detail/yedeqixian/4209500
      80页在讲KMP算法的开始先举了个例子，让我们对KMP的基本思想有了最初的认识。目的在于指出“由此，在整个匹配的过程中，i指针没有回溯，”。
我们继续往下看：
现在讨论一般情况。
假设 主串：s: ‘s(1)  s(2)  s(3) ……s(n)’ ;   模式串 ：p: ‘p(1)  p(2)  p(3)…..p(m)’

把课本上的这一段看完后，继续
现在我们假设 主串第i个字符与模式串的第j(j<=m)个字符‘失配’后，主串第i个字符与模式串的第k(k<j)个字符继续比较
此时，s(i)≠p(j),  有
主串：               S(1)……  s(i-j+1)…… s(i-1)   s(i) ………….
                                || (相配)   ||       ≠(失配)
匹配串：                        P(1) …….  p(j-1)   p(j)  
由此，我们得到关系式
          ‘p(1)  p(2)  p(3)…..p(j-1)’   =    ’ s(i-j+1)……s(i-1)’
由于s(i)≠p(j)，接下来s(i)将与p(k)继续比较，则模式串中的前(k-1)个字符的子串必须满足下列关系式，并且不可能存在  k’>k  满足下列关系式：(k<j),
          ‘p(1)  p(2)  p(3)…..p(k-1)’   =    ’ s(i-k+1)s(i-k+2)……s(i-1)’
即：
主串：        S(1)……s(i-k +1) s(i-k +2) ……s(i-1)     s(i) ………….
                        || (相配)  ||           ||       ?(有待比较)
匹配串：                P(1)      p(2)    …… p(k-1)    p(k)
现在我们把前面总结的关系综合一下
有：
 S(1)…s(i-j +1)…  s(i-k +1) s(i-k +2)  ……    s(i-1)     s(i) ……
           || (相配)  ||         ||               ||         ≠(失配)
           P(1) ……p(j-k+1)   p(j-k+2)  …....   p(j-1)    p(j) 
                      || (相配)  ||               ||          ?(有待比较)
                      P(1)       p(2)    …….    p(k-1)      p(k)
由上，我们得到关系：
‘p(1)  p(2)  p(3)…..p(k-1)’   =    ’ s(j-k+1)s(j-k+2)……s(j-1)’

接下来看“反之，若模式串中存在满足式(4-4)。。。。。。。”这一段。看完这一段，如果下面的看不懂就不要看了。直接去看那个next函数的源程序。(伪代码)
K 是和next有关系的，不过在最初看的时候，你不要太追究k到底是多少，至于next值是怎么求出来的，我教你怎么学会。
课本83页不是有个例子吗？就是  图4.6
你照着源程序，看着那个例子慢慢的推出它来。看看你做的是不是和课本上正确的next值一样。
然后找几道练习题好好练练，一定要做熟练了。现在你的脑子里已经有那个next算法的初步思想了，再回去看它是怎么推出来的，如果还看不懂，就继续做练习，做完练习再看。相信自己！！！

附：

KMP算法查找串S中含串P的个数count 
#include <iostream>
#include <stdlib.h>
#include <vector>
using namespace std;
inline void NEXT(const string& T,vector<int>& next)
{
    //按模式串生成vector,next(T.size())    
    next[0]=-1;             
    for(int i=1;i<T.size();i++ ){
        int j=next[i-1];
        while(T[i]!=T[j+1]&& j>=0 )
         j=next[j] ;  //递推计算
        if(T[i]==T[j+1])next[i]=j+1;  
        else next[i]=0;  //
    }    
}  
inline string::size_type COUNT_KMP(const string&  S,
                    const string&  T)
{
    //利用模式串T的next函数求T在主串S中的个数count的KMP算法
    //其中T非空， 
    vector<int> next(T.size());
    NEXT(T,next);
    string::size_type index,count=0;    
    for(index=0;index<S.size();++index){       
        int pos=0;
        string::size_type iter=index; 
        while(pos<T.size() && iter<S.size()){
            if(S[iter]==T[pos]){
                ++iter;++pos;
            }
            else{
                if(pos==0)++iter;               
                else pos=next[pos-1]+1;
            }    
        }//while end
        if(pos==T.size()&&(iter-index)==T.size())++count;
    } //for end
    return count;
}
int main(int argc, char *argv[])
{
    string S="abaabcacabaabcacabaabcacabaabcacabaabcac";
    string T="ab";
    string::size_type count=COUNT_KMP(S,T);
    cout<<count<<endl; 
  
  system("PAUSE"); 
  return 0;
}

关于KMP算法当中的next函数

首先先贴出KMP算法的框架代码，这段代码使用C语言当中的字符串数据结构，因此字符串当中第一个字符的下标为零。

int Index(const char * str1,const char * str2,int pos)
{
    int * nextFunc = get_next(str2);
    int strLen = strlen(str1);
    int subLen = strlen(str2);
    int i = pos,j = 0;
    while (i < strLen && j < subLen)
 {
        if (j == -1 || str1[i] == str2[j])
    {
            i++;
            j++;
        }
        else
            j = nextFunc[j];
    }
    if (j == subLen)
        return i - subLen;
    return -1;
}
        相比较那种最简单的算法而言这里的神奇之处在于一个next函数，由于这个next函数的存在导致我们在模式匹配过程当中某个字符出现失配的情况时不再需要回溯主串当中的指针i到开始匹配时的位置。所有的数据结构或者算法的书都告诉我们说，之所以不需要回溯这个i指针是因为在匹配过程当中产生了一些附加的信息，利用这些附加信息就可以得到这样的性能改进。

首先我们必须搞清楚这个神奇的next函数的含义。next[j]=k 这样一个式子表示的含义是，当主串当中第i个元素与模式串当中第j个元素不匹配时我们应该保持i指针不动而将模式串当中的j指针移动到k这个位置，然后再比较主串的第i个元素与模式串的第k个元素是否匹配，匹配当然没话说照最传统的算法移动两个指针比较下一个元素或者得到完全匹配的结果，不匹配那么再做那个动作，也就是求next[k]=？，然后再比较。

之所以存在这么一个next函数是因为，如果说主串与模式串在匹配过程当中主串的第i个元素与模式串的第j个元素不同，那么隐含的意义是主串的从第i-j+1个元素到第i-1个元素与模式串的第1个元素到第j-1个元素是相同的。那么如果说这样不能达到最后全部匹配的结果也就是上面讲的主串[i] != 模式串[j]，那么我们应该从主串的i-j+1到i-1这个字串当中从后到前寻找一个最大子串与模式串的第1到j-1这个字串的从第一个到某个元素的最大子串完全匹配。而我们又知道主串中第i-j+1个元素到第i-1个元素的子串事实上就是模式串当中第1个元素到第j-1个元素所形成的子串。next函数所完成的工作就是这个寻找匹配的工作，他的返回值就是这个子串的最后一个元素的下一个位置。为什么是这个位置，前面讲的很清楚，就是说既然前面那一串匹配，那么接下来要比较的就是这个位置的元素。下面开始描述next函数的求法。

从上面的描述我们可以知道next函数的值完全只与模式串相关而与主串是什么样子的没有任何关系，因此来说对于每个模式串都有一个唯一的next串值。求法是这样，如果说自变量为0也就是说第一个元素的next值固定为-1(-1的意思是说，主串的当前位置元素与模式串第一个元素的前一个元素匹配，隐含意义是讲主串指针必须往后移一位再与模式串的第一个元素比较)；如果next[j] = k也就是说模式串的第1个元素到第k个元素与第j-k+1个元素到第j-1个元素相等相等(可以按照上面的方法推出到主串上哪几个元素)，而且有模式串[j] == 模式串[k]那么可以得到next[j+1] = k+1(这里的原理显而易见)；如果不等那么就求另外一个最大子串，方法就是j = next[k]，然后再回到上面的比较。而其他的情况就视作next值为0(事实上只有求j=1时的next值才会出现，所以next值的前两个元素固定是0和1)。具体算法如下：

int * get_next(const char * str)
{
    int strLen = strlen(str);
    int * nextFunc = new int[strLen];
    if (!nextFunc)
        return 0;
    nextFunc[0] = -1;
    int i = 0,j = nextFunc[i];
    while (i < strLen)
{
        if (j == -1 || str[i] == str[j])
    {
            i++;
            j++;
            nextFunc[i] = next[i-1] + 1;
        }
        else
            j = nextFunc[j];                     
    }
    return nextFunc;
}
注：本文所有的串表示方法都是C语言的默认表示方法，也就是第一个元素的下标为0

设s=” s1 s2 ... sn ”， t=” t1 t2 ... tm ”，在匹配过程中，当si≠ tj(1≤i≤n-m+1,1≤j≤m)时，存在（前面的j-1个字符已匹配）：
” si-j+1 ... si-1 ” =” t1 t2 ... tj-1 ”          (1)
若模式中存在可互相重叠的最长的真子串，满足：
  ” t1 t2 ... tk-1 ”=”tj-k+1 tj-k+2 ... tj-1 ”            (2)
其中真子串最短可以是t1 ，即 t1。。。t2-1  (k>1)，最长的是t1。。。tj-1-1  (k<j)，所以(1<k<j)。
由(1)式说明模式串中的子串” t1 t2 ... tk-1 ”已和主串”si-k+1 si-k+2 ... si-1 ”匹配，下一次可直接比较si 和tk ，若不存在（2）式，则结合（1）式说明在” t1 ... tj-1 ” 中不存在任何以t1 为首字符子串与”si-j+1 si-j+2 ... si-1 ”中以si-1 为末字符的匹配子串，下一次可直接比较si  和t1 。主串指针的不回溯，。
 例（p82）：主串 a c a b a a b a a b c a c a a b c
           模式 a b a a b c a c
现在的问题是要求next函数，next(j)的作用是，当si与tj匹配失败时，si与tnext(j)匹配。
next函数的定义如下：
↓↓↓↓↓↓↓↓↓图形拖放
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 例：根据定义手工求模式 a b a a b c a c的next函数：
（1）next(1)=0
（2）next(2)=1  (t1 =a中不存在真子串，即不存在k满足1<k<2)
（3）next(3)=1  (t1 t2=a b没有重叠真子串)
（4）next(4)=2  (t1 ...t3=a b a有重叠真子串t1 和t3，所以k=2)（最后一位与前几位是否有重叠的串）
（5）next(5)=2  (t1 ...t4=a b a a有重叠真子串t1 和t4，所以k=2)
（6）next(6)=3  (t1 ...t5=a b a a b有重叠真子串t1t2 和t3t4，所以k=3)
（7）next(7)=1  (t1 ...t6=a b a a b c没有重叠真子串)
（8）next(8)=2  (t1 ...t7=a b a a b c a有重叠串t1 和t7，所以k=2)
求模式 a b a a b c a c的next函数的算法：
因为已知next(1)=0,只要找出next(j+1)与next(j)之间的关系，就可以求出模式串所有next(j)。
/////////////////////////图形拖放开始////////////////////////////////////
求next函数算法（p83）：（非常好的解释和例子）
void get_next(sstring T, int &next[])
{
  //求模式串T的next函数值并存入数组next。
  j=1; k=next[j]=0;
  while (j<T[0])    //计算next(j)从next(2)到next(T[0])，T[0]是T的长度
//但并不意味着只循环m-1次，因为在循环体中j的值可能不发生变化
    if (k==0||T[j]==T[k])// 没有重叠真子串和（有重叠真子串但T[j]==T[k]）时
                     //都应该得出next(j+1)的值
      next[++j]=++k;//书上：{++j ; ++k; next[j]=k;} 
    else k=next(k);//否则，得不出next(j+1)的值，所以j不变，k退回到next(k)，重复匹配。
}//end of get_next
不加注看起来更简洁一些：
void get_next(sstring T, int &next[])
{
  j=1;  k=next[j]=0;
  while (j<T[0])    
    if (k==0||T[j]==T[k]) 
      next[++j]=++k;
    else k=next(k); 
}//end of get_next

仍以模式串a b a a b c a c 为例，验证一下该算法。
(1)next[1]=0
(2)j=1；k=0; 
   满足k==0;所以j=2;k=1;next[2]=1
(3) j=2；k=1; 
   不满足k==0也不满足T[2]==T[1];所以k=next[k]=next[1]=0
j=2；k=0;
   满足k==0;所以j=3;k=1;next[3]=1
(4) j=3；k=1; 
   满足T[3]==T[1];所以j=4;k=2;next[4]=2
(5) j=4;k=2;  
   不满足k==0也不满足T[4]==T[2];所以k=next[k]=next[2]=1
j=4;k=1;
满足T[4]==T[1];所以j=5;k=2;next[5]=2
(6) j=5;k=2;
满足T[5]==T[2];所以j=6;k=3;next[6]=3
(7) j=6;k=3;
   不满足k==0也不满足T[6]==T[3];所以k=next[k]=next[3]=1
   j=6;k=1;
   不满足k==0也不满足T[6]==T[1];所以k=next[k]=next[1]=0
   j=6;k=0;
   满足k==0;所以j=7;k=1;next[7]=1
(8) j=7;k=1;
满足T[7]==T[1];所以j=8;k=2;next[8]=2
 

利用next值表进行匹配的过程：
假设以i和j分别指示主串和模式串中正待比较的字符，若si=tj ,则i和j分别增1，否则，i不变，而j退回到next[j]的位置再比较，若j退回到值为0（即模式的第一个字符失配），则将模式继续向右滑动一个位置，即从主串的下一个字符si+1起和模式重新开始匹配。
 
      

KMP算法：
int index_KMP(sstring s, sstring t, int pos)
{
   //利用模式串的next函数求t在主串s中第pos个字符之后的位置的KMP算法，
   //t非空，1<=pos<=strlength(s)
   i=pos; j=1;
   while(i<=s[0]&&j<=t[0])
   {
   if (j==0||s[i]==t[j]){++i;++j;}
   else j=next[j];
}
if (j>t[0]) return i-t[0];
else return 0;
}//index_kmp

所以next函数可以做这样的改进：在原next基础上，若t[j]=t[k]，k=next[k]，直到t[j]<>t[k]。在程序中可以不用循环，因为在计算前面的nextval时已经做了修正，只需作nextval[j]= nextval[k]即可。

void get_nextval(sstring T, int &nextval[])
{
  //求模式串T的next函数修正值并存入数组nextval。
  j =1; k= nextval[j ]=0;
  while (j<T[0])    //计算next(j)从next(2)到next(T[0])，
    if (k==0||T[j]==T[k])// 没有重叠真子串和（有重叠真子串但T[j]==T[k]）时都能够得出结论
    {  ++j;++k;
if (T[j]!=T[k]) nextval[j]=k;//这时的T[j]事实上是T[j+1]，T[k]事实上是T[k+1]
else nextval[j]= nextval[k];
}
    else k=next(k);//否则，j不变，k退回到next(k)。
}//end
用此函数计算模式“aaaab”的nextval值。
（1）nextval[1]=0
（2）j=1,k=0j=2,k=1,! (T[j]!=T[k])nextval[2]= nextval[1]=0
（3）j=2,k=1, T[j]==T[k]j=3,k=2, ! (T[j]!=T[k]) nextval[3]= nextval[2]=0
（4）j=3,k=2, T[j]==T[k]j=4,k=3, ! (T[j]!=T[k]) nextval[4]= nextval[3]=0
（5）j=4,k=3, T[j]==T[k]j=5,k=4, (T[j]!=T[k]) nextval[5]=4

KMP算法的优化

　　KMP算法是可以被进一步优化的。

　　我们以一个例子来说明。譬如我们给的P字符串是“abcdaabcab”，经过KMP算法，应当得到“特征向量”如下表所示：

但是，如果此时发现p(i) == p(k)，那么应当将相应的next[i]的值更改为next[k]的值。经过优化后可以得到下面的表格：

　　

附：

　　KMP算法查找串S中含串P的个数count

　　#include <iostream>

　　#include <stdlib.h>

　　#include <vector>

　　using namespace std;

　　inline void NEXT(const string& T,vector<int>& next)

　　{

　　//按模式串生成vector,next(T.size())

　　next[0]=-1;

　　for(int i=1;i<T.size();i++ ){

　　int j=next[i-1];

　　while(T[i]!=T[j+1]&& j>=0 )

　　j=next[j] ; //递推计算

　　if(T[i]==T[j+1])next[i]=j+1;

　　else next[i]=0; //

　　}

　　}

　　inline string::size_typeCOUNT_KMP(const string& S,

　　const string& T)

　　{

　　//利用模式串T的next函数求T在主串S中的个数count的KMP算法

　　//其中T非空，

　　vector<int> next(T.size());

　　NEXT(T,next);

　　string::size_type index,count=0;

　　for(index=0;index<S.size();++index){

　　int pos=0;

　　string::size_type iter=index;

　　while(pos<T.size() && iter<S.size()){

　　if(S[iter]==T[pos]){

　　++iter;++pos;

　　}

　　else{

　　if(pos==0)++iter;

　　else pos=next[pos-1]+1;

　　}

　　}//while end

　　if(pos==T.size()&&(iter-index)==T.size())++count;

　　} //for end

　　return count;

　　}

　　int main(int argc, char *argv[])

　　{

　　string S="abaabcacabaabcacabaabcacabaabcacabaabcac";

　　string T="ab";

　　string::size_type count=COUNT_KMP(S,T);

　　cout<<count<<endl;

　　system("PAUSE");

　　return 0;

　　}