【算法基础课】KMP算法

一、KMP逻辑过程的动态演示

来源：「天勤公开课」KMP算法易懂版

所谓“逻辑过程”，而不是“程序”，就是以人能理解的动作来表示KMP。之后我们再从这个过程中找规律，把这些动作翻译为程序。

1.问题描述

如下图所示：我们需要在文本（蓝色）中快速找到和模式串（黄色）相同的子串。

2.暴力解法

对于暴力解法：我们逐个对比上下两个串的字符，假设文本当前的指针为i，模式串指针为j。

发现不匹配时，我们让模式串后移一格。此时，i由刚才的5又退回了1。而j自然是0。

正是由于i每次都要回退，所以暴力算法才效率低下。KMP算法可以实现让i不再回退。那么它是怎么做到的呢？

3.KMP解法

假设目前遇到了一个不匹配的字符。已知前面的字符都是相同的。

我们还可以发现，左边的“ABBAB”的前端和后端有相同的子串（公共前后缀）。

接着，我们可以把模式串移动一下：“ABBAB”是5位，前后缀有2位相同，需要移动“5-2”位才能让前缀和后缀对齐。如果前后缀有3位相同，那移动2位可以对齐，依次类推:$$需要移动的位数=“已匹配子串位数”-“公共前后缀位数”$$

那原来的i=5左边的子串是不是就匹配上了呢，我们可以直接从i=5开始，继续和模式串向后比较，不需要再回退i啦！

只看模式串，我们上面的操作是移动了3格，如果移动1格或2格就能让匹配的子串更长的话，那公共前后缀应该是那个新匹配的“更长子串”才对，然而并非如此。所以，我们可以证明，将前缀移动到后缀的位置，是可以移动的最大距离，不会让我们漏掉可能匹配的其他情况。

同时，我们也要考虑到，如果有多个公共前后缀，我们要选择最长的那个。

文本和模式串左边匹配的内容完全相同，所以我们只研究模式串就够了。

我们存储模式串时，从下标1开始。拿来和文本进行比较的时候，每个位置都可能发生不匹配的情况。

假如第一个位置就不匹配：我们需要让1号位和文本（主串）的下一位比较。

如果2号位不匹配，我们需要找公共前后缀，因为“A”只有1位，所以无公共前后缀（小于字符串总位数），应该移动的位数为（1-0）=0。

3号位上同样没有公共前后缀。

当4号位不匹配时，找到最长公共前后缀，位数为1，所以移动位数为2，此时公共前缀的下一位与i进行比较，即2号位。从这里我们就可以看出规律了：i与公共前后缀的位数+1的字符进行比较即可。

所以，我们可以把模式串上的每一位它的左边子串的“最大公共前后缀长度”存储起来，就能知道i下一次应该与模式串中的哪个字符比较了。存储起来的这个数组，就是大名鼎鼎的“next数组”。

对于1号位的特殊情况，我们可以用“0”表示：

二、例题与模板

1.题目

给定一个模式串S，以及一个模板串P，所有字符串中只包含大小写英文字母以及阿拉伯数字。模板串P在模式串S中多次作为子串出现。求出模板串P在模式串S中所有出现的位置的起始下标。

输入格式
第一行输入整数N，表示字符串P的长度。第二行输入字符串P。第三行输入整数M，表示字符串S的长度。第四行输入字符串S。

输出格式
共一行，输出所有出现位置的起始下标（下标从0开始计数），整数之间用空格隔开。

数据范围
$1\le N\le 105$
$1\le M\le 106$

输入样例：

3
aba
5
ababa

输出样例：

0 2

2.有next数组后的匹配代码

首先获取一下数据：

#include <iostream>
using namespace std;
const int N = 100010, M = 10010; //N为模式串长度，M匹配串长度

int n, m;
int ne[M]; //next[]数组，避免和头文件next冲突
char s[N], p[M];  //s为模式串， p为匹配串

int main()
{
    cin >> n >> s+1 >> m >> p+1;  //下标都从1开始
    ……
    return 0;
}

假装获取了next数组：

【注意】next数组里存储的实际上是“最大公共前后缀的位数”，而下一个要比较的应该是这个数字加一。next数组从0下标开始存，前两位的值都是0。

匹配的代码：

假设j=1：

for(int i = 1, j = 1; i <= n; i++)
{
	if(j==1){
		if(s[i]==p[j]){//1号位匹配了
			j++;
			if(j==m+1)j=ne[j-1]+1;					
		}
		else j=1;//1号位不匹配
	}
	else{
		//j>=2
		while(j!=1&&s[i]!=p[j]){
			j=ne[j-1]+1;//2号及以上位不匹配	
			//移动之后，可能需要判断1号位了		
		}
		if(s[i]==p[j]){
			j++;
			if(j==m+1)j=ne[j-1]+1;
		}
	}
}

上述代码还可以简化：把j=ne[j-1]+1中的j变为j+1，可以得到j+1=ne[j+1-1]+1即j=ne[j]。也就是说，我们可以把初始值j=1变为j=0。

for(int i = 1, j = 0; i <= n; i++)
{
	if(j==0){
		if(s[i]==p[j+1]){//1号位匹配了
			j++;						
		}
		if(j==m)j=ne[j];		
	}
	else{
		//j>=1
		while(j!=0&&s[i]!=p[j+1]){
			j=ne[j];//2号及以上位不匹配	
			//移动之后，可能需要判断1号位了		
		}
		if(s[i]==p[j+1]){
			j++;			
		}
		if(j==m)j=ne[j];
	}
}

把重复代码去掉，就是：

for(int i = 1, j = 0; i <= n; i++)
{
	//j>=1
	while(j && s[i] != p[j+1])j=ne[j];
		
	if(s[i]==p[j+1])j++;//j指向当前匹配的字符的位置			

	if(j==m)j=ne[j-1]+1;
}

3.求next数组的代码

next数组的求法是通过模板串自己与自己进行匹配操作得出来的。代码和匹配操作的代码几乎一样，关键在于每次移动 i 前，将 i 前面已经匹配的长度记录到next数组中。

ABABACBA
 ABABACBA

我们直接从next数组的第三个元素开始存：

for(int i = 2, j = 0; i <= m; i++)
{
    while(j && p[i] != p[j+1]) j = ne[j];

    if(p[i] == p[j+1]) j++;//j指向当前匹配的字符的位置

    ne[i] = j;//即在第三个元素处，当前匹配的字符个数
}

• i==2，j=0; 即ne[2]=0。i=2时，获取的正好就是第三位前的字符串的最大公共前后缀。判断第一位和第二位是否相等。

• i==3，j=1; 即ne[3]=1。i=3时，获取的正好就是第四位前的字符串的最大公共前后缀。判断第一位和第三位是否相等。

• i==4，j=2; 即ne[4]=2。i=4时，获取的正好就是第五位前的字符串的最大公共前后缀。判断前两位和后两位是否相等（前一位和第一位已经相等了）。

4.完整代码

#include <iostream>

using namespace std;

const int N = 100010, M = 10010; //N为模式串长度，M匹配串长度

int n, m;
int ne[M]; //next[]数组，避免和头文件next冲突
char s[N], p[M];  //s为模式串， p为匹配串

int main()
{
    cin >> n >> s+1 >> m >> p+1;  //下标从1开始

    //求next[]数组
    for(int i = 2, j = 0; i <= m; i++)
    {
        while(j && p[i] != p[j+1]) j = ne[j];
        if(p[i] == p[j+1]) j++;
        ne[i] = j;
    }
    //匹配操作
    for(int i = 1, j = 0; i <= n; i++)
    {
        while(j && s[i] != p[j+1]) j = ne[j];
        if(s[i] == p[j+1]) j++;
        if(j == m)  //满足匹配条件，打印开头下标, 从0开始
        {
            //匹配完成后的具体操作
            //如：输出以0开始的匹配子串的首字母下标
            //printf("%d ", i - m); (若从1开始，加1)
            j = ne[j];            //再次继续匹配
        }
    }

    return 0;
}

三、来应用吧！

力扣28.实现strStr()

题目要求：

代码：

（背会了模板，做题快得一p。一看题目就知道用什么算法解决，代码也非常熟练哈哈哈哈，是理想状态了~）

class Solution {
public:
    int strStr(string haystack, string needle) {
        if(needle.size()==0)return 0;
        int n=haystack.size();
        int m=needle.size();
        vector<char> s(n+10),p(m+10);
        for(int i=0;i<n;i++){
            s[i+1]=haystack[i];
        }
        for(int i=0;i<m;i++){
            p[i+1]=needle[i];
        }
        vector<int> ne(m+10,0);
        int ans=-1;
        //求next数组
        for(int i=2,j=0;i<=m;i++){
            while(j&&p[i]!=p[j+1]) j=ne[j];
            if(p[i]==p[j+1])j++;
            ne[i]=j;
        }
        //匹配
        for(int i=1,j=0;i<=n;i++){
            while(j&&s[i]!=p[j+1]) j=ne[j];
            if(s[i]==p[j+1])j++;
            if(j==m){
                ans=i-needle.size();
                break;
            }
        }
        return ans;
    }
};