KMP

Posted 2021-01-11 bigyellowdog

• 首先文章开始前放一篇吾认为很不错的文章：传送门
• 此篇博客为合成文章：即诸多博客内容+个人理解

KMP

KMP是什么？

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

引入

• 例题如下：给你字符串s1, s2。找出s2在s1中出现的位置
• 分析：看到这一题，暴力思路很容易想到，即从目标字符串str（假设长度为n）的第一个下标选取和ptr长度（长度为m）一样的子字符串进行比较，如果一样，就返回开始处的下标值，不一样，选取str下一个下标，同样选取长度为n的字符串进行比较，直到str的末尾（实际比较时，下标移动到n-m）。但这样时间复杂度是O(n*m)。
• 思考：为什么暴力法会慢，慢在哪儿？如何改进？
• 进一步分析：因为有些已经相等的字符在重复比较，但这些比较是多余的。为什么这样说，举个例子就懂了：
  
  如图所示，当比较到第4位时，C != D，所以按照暴力想法应该i挪到2继续比较。但我们仔细观察可以发现，i可以不挪到2、3去。因为即使挪到那儿也不能成功匹配。因为前面3个成功匹配，而把i挪到2、3不就错位了吗？那就更不可能成功匹配了。
• 结论：暴力算法慢在已经相等的字符重复比较比较。而KMP算法就弥补了这个缺点，即利用已经部分匹配这个有效信息，保持i指针不回溯，通过修改j指针，让模式串尽量地移动到有效的位置。从而达到O(m+n)的复杂度

算法框架/流程

1. 算出每个位置的next
2. 开始比对

1. 算出每个位置的next

• 设next[j] = k，表示当主串[i] != 目标串[j]时，j指针的下一个位置。
• 含义：就是一个固定字符串的 <最长前缀和最长后缀相同> 的长度。
• 如何算next，看个例子：
  • 比如：abcjkdabc，那么这个数组的最长前缀和最长后缀相同必然是abc。
  • cbcbc，最长前缀和最长后缀相同是cbc。

  • abcbc，最长前缀和最长后缀相同是不存在的。

  • 注意最长前缀：是说以第一个字符开始，但是不包含最后一个字符。
    比如aaaa相同的最长前缀和最长后缀是aaa。

  • 对于目标字符串ptr，ababaca，长度为7，所以next[0], next[1], next[2], next[3],next[4],next[5],next[6]分别计算的是a,ab,aba,abab,ababa,ababac,ababaca的相同的最长前缀和最长后缀的长度。由于a,ab,aba,abab,ababa,ababac,ababaca的相同的最长前缀和最长后缀是“”，“”，“a”，“ab”，“aba”，“”，“a”,所以next数组的值是[-1,-1,0,1,2,-1,0]，这里-1表示不存在，0表示存在长度为1，2表示存在长度为3。这是为了和代码相对应。
• 可能你会问：看了那么多，next数组到底有什么用啊！看了前面那么多，你可能有所领悟，即：当主串[i] != 目标串[j]，不需要移动i指针，只需让j指针移动到next[j]即可。
• 代码如下：

void getNext()
{
    next[0]=-1; ////next[0]初始化为-1，-1表示不存在相同的最大前缀和最大后缀
    int k=-1;   //k为相同的最大前缀和最大后缀长
    for(int i=1;i<lenb;i++)
    {
        while(k>-1 && s2[k+1]!=s2[i]) k=next[k];
        if(s2[k+1]==s2[i]) k++;
        next[i]=k;
    }
}

2. 开始比对

• 即寻找目标串的过程。有了next数组就非常好处理了。具体看代码

void kmp()
{
    int j=-1;   //为目标串的指针
    for(int i=0;i<lena;i++)
    {
        while(j>-1 && s2[j+1]!=s1[i]) j=next[j];    //主串和目标串不匹配，且k>-1
        if(s2[j+1]==s1[i]) j++;
        if(j==lenb-1)   ////说明j移动到目标串的最末端（找到了）
        {
            cout<<i-lenb+1+1<<endl; //输出这个目标串所在位置
            j=-1;   //重新初始化，寻找下一个目标串的位置
            i=i-lenb+1; //i定位到该位置，外层for循环i++可以继续找下一个
        }
    }
}

实现代码

以模版题为例：传送门

#include <iostream>
#include <cstdio>
#include <string>
#define maxn 1000005
using namespace std;

string s1, s2;
int lena, lenb;
int next[maxn];

void getNext()
{
    next[0]=-1;
    int k=-1;   //k为相同的最大前缀和最大后缀长
    for(int i=1;i<lenb;i++)
    {
        while(k>-1 && s2[k+1]!=s2[i]) k=next[k];
        if(s2[k+1]==s2[i]) k++;
        next[i]=k;
    }
}

void kmp()
{
    int j=-1;
    for(int i=0;i<lena;i++)
    {
        while(j>-1 && s2[j+1]!=s1[i]) j=next[j];
        if(s2[j+1]==s1[i]) j++;
        if(j==lenb-1)
        {
            cout<<i-lenb+1+1<<endl;
            j=-1;
            i=i-lenb+1;
        }
    }
}

int main()
{
    cin>>s1>>s2;
    getNext();
    kmp();
    for(int i=0;i<lenb;i++) cout<<next[i]+1<<" ";
    return 0;
}

补充

大家可能对getNext()函数和KMP()函数里的

while(k>-1 && s2[k+1]!=s2[i]) k=next[k];

和

while(j>-1 && s2[j+1]!=s1[i]) j=next[j];

这个while循环和k=next[k]很疑惑！
确实啊，我开始看这几行代码，相当懵逼，这写的啥啊，为啥这样写；后来上机跑了一下，慢慢了解到为何这样写了。这几行代码，可谓是对KMP算法本质得了解非常清楚才能想到的。这也是KMP算法的精髓所在
直接看cal_next(..)函数：
首先我们看第一个while循环，它到底干了什么。

在此之前，我们先回到原程序。原程序里有一个大的for()循环，那这个for()循环是干嘛的？
这个for循环就是计算next[0]，next[1],…next[i]…的值。
里面最后一句next[i]=k就是说明每次循环结束，我们已经计算了目标串的前(i+1)个字母组成的子串的“相同的最长前缀和最长后缀的长度”。（这句话前面已经解释了！） 这个“长度”就是k。

好，到此为止，假设循环进行到 第 i 次，即已经计算了next[i]，我们是怎么计算next[i+1]呢？

比如我们已经知道ababab，i=4时，next[4]=2（k=2，表示该字符串的前5个字母组成的子串ababa存在相同的最长前缀和最长后缀的长度是3，所以k=2,next[4]=2。这个结果可以理解成我们自己观察算的，也可以理解成程序自己算的，这不是重点，重点是程序根据目前的结果怎么算next[5]的）.，那么对于字符串ababab，我们计算next[5]的时候，此时i=5, k=2（上一步循环结束后的结果）。那么我们需要比较的是目标串[k+1]和目标串[i]是否相等，其实就是目标串[1]和目标串[5]是否相等！为啥从k+1比较呢，因为上一次循环中，我们已经保证了目标串[k]和目标串[i]是相等的（这句话自己想想，很容易理解），所以到本次循环，我们直接比较目标串[k+1]和目标串[i]是否相等。
如果相等，那么跳出while()，进入if()，k=k+1，接着next[i]=k。即对于ababab，我们会得出next[5]=3。 这是程序自己算的，和我们观察的是一样的。
如果不等，我们可以用”ababac“描述这种情况。 不等，进入while()里面，进行k=next[k]，这句话是说，在目标串[k + 1] != 目标串[i]的情况下，我们往前找一个k，使目标串[k + 1]==目标串[i]，是往前一个一个找呢，还是有更快的找法呢？ KMP程序给出了一种更快的找法，那就是 k = next[k]。 程序的意思是说，一旦目标串[k + 1] != 目标串[i]，即在后缀里面找不到时，我是可以直接跳过中间一段，跑到前缀里面找，next[k]就是相同的最长前缀和最长后缀的长度。所以，k=next[k]就变成，k=next[2]，即k=0。此时再比较目标串[0+1]和目标串[5]是否相等，不等，则k=next[0]=-1。跳出循环。