KMP

简介：

KMP算法，适用于模式匹配，即查找模式串P在字符串S内的出现位置，其时间复杂度为O(M+N)。

(题外话：模式匹配问题是算法竞赛的常客，但理解KMP算法具有一定难度，建议先理解BF算法后再理解KMP算法。当然，网上关于KMP算法的讲解很多，这里仅仅只是给出模板。)

模板：

下面给出2种求next数组的方法，其中优化next数组求法虽然使得kmp算法更快，但针对需要输出模式串p的next数组的算法题，往往多数都是要原方法求出next数组。两种方法求出的next数组有什么区别可以通过网上关于KMP算法的讲解了解到。

//求出模式串p的next数组 
void Next(char* p,int *next)
{    
    int pLen = strlen(p);
    next[0] = -1;
    int k = -1;
    int j = 0;
    
    while (j < pLen){
        //p[k]表示前缀，p[j]表示后缀
        if (k == -1 || p[k] == p[j]) {
            ++k;
            ++j;
            next[j] = k;
        }else{
            k = next[k];
        }
    }
}

//优化next数组求法
void Next(char* p, int *next)
{
    int pLen = strlen(p);
    next[0] = -1;
    int k = -1;
    int j = 0;
    
    while (j < pLen)
    {
        if (k == -1 || p[k] == p[j]){
            ++j;
            ++k;
            //改动在下面4行
            if (p[j] != p[k])
                //之前只有这一行
                next[j] = k;   
            else
                //为了避免出现p[j] = p[ next[j] ]，需要再次递归
                next[j] = next[k];
        }else{
            k = next[k];
        }
    }
}

下面给出不同版本的kmp算法代码，核心算法不变，但根据目的不同进行了相应的修改。

//返回模式串p在字符串s中首次出现的位置 
int KMP(char* s, char* p)
{
    int i = 0;
    int j = 0;
    int sLen = strlen(s);
    int pLen = strlen(p);

    while (i < sLen && j < pLen){
        //如果j = -1，或当前字符匹配成功（即S[i] == P[j]），都令i++，j++    
        if (j == -1 || s[i] == p[j]){
            i++;
            j++;
        }
        //如果j != -1，且当前字符匹配失败（即S[i] != P[j]），则令 i 不变，j = next[j]     
        else{ 
            j = next[j];
        }
    }

    if (j == pLen)
        //返回匹配到的位置 
        return i - j+1;
    else
        //匹配失败，返回0 
        return 0;
}

//输出模式串p在字符串s中出现的所有位置 
void kmp(char *s,char *p)
{
    int pLen=strlen(p);
    int sLen=strlen(s);
    int i=0;
    int j=0;
    
    while(i<sLen && j<pLen)
    {
        if(j==-1 || s[i]==p[j])
        {
            i++;
            j++;
        }else{
            j=next[j];
        }
        
        if(j==pLen)
        {
            //输出匹配到的位置 
            cout<<i-j+1<<endl;
            //j进行递归，i不需要改变 
            j=next[j];
        }
    }
}

例题：洛谷P3375

（一道模板题）

const int Size = 1000000+7;

char s[Size],p[Size];
int  next[Size];

void Next(char *p,int *next)
{
    int pLen=strlen(p);
    int k=-1;
    int j=0;
    next[0]=-1;
    
    while(j<pLen)
    {
        if(k==-1 || p[j]==p[k])
        {
            j++;
            k++;
            next[j]=k;
        }else{
            k=next[k];
        }    
    }    
} 

void kmp(char *s,char *p)
{
    int pLen=strlen(p);
    int sLen=strlen(s);
    int i=0;
    int j=0;
    
    while(i<sLen && j<pLen)
    {
        if(j==-1 || s[i]==p[j])
        {
            i++;
            j++;
        }else{
            j=next[j];
        }
        
        if(j==pLen)
        {
            cout<<i-j+1<<endl;
            j=next[j];
        }
    }
}

int main()
{
    scanf("%s",s);
    scanf("%s",p);
    
    Next(p,next);
    kmp(s,p);
    
    //注：遍历从下标1开始
    int pLen=strlen(p);
    for(int i=1;i<=pLen;i++)
    {
        printf("%d ",next[i]);
    }
}