2021-09-09 关于kmp算法的理解 c++

//读 hsz推荐的 写的特别好特别细的 阮行止–关于kmp的算法的知乎回答 有感

KMP算法

KMP算法是一种字符串匹配算法以时间复杂度O(m+n)(m,n分别为S,P的长度）

替代了原本的暴力算法—Brute-Force

Brute-Force

从前往后逐字符比较，一旦遇到不相同的字符，就返回False；如果两个字符串都结束了，仍然没有出现不对应的字符，则返回True

该方法的时间复杂度为O(mn)(m,n分别为S，P的长度）
暴力算法 实现代码如下

int bruteForce(char *S,char *P){
	int m = S.size();
	int n = P.size();
	for(int i = 0; i <= m - n; i++){
		int flag = true;
		for(int j = 0; P[j] != '\0'; j++){
			if(s[i+j] != P[j]){
				flag = false;
				break;
			}
		}
	}
	if(flag)
		return i;
}

问题简介

如图所示：

S 是主串
P 是模式串

QUESTION ：模式串P 是否能在主串S中匹配

题中要求的 即 在主串S 中匹配模式串P
暴力算法由于比较趟数过多而超时，因此：可通过减少比较的趟数，提高效率。

思路引入

如何减少比较的趟数？

以一个例子引入：

这次匹配失败后，按照暴力算法，会将P向后移一位，进行下一轮的匹配

但我们发现在第一个字符就失配了，后面3轮同样

跳过不可能匹配成功的字符串比较 来减少比较次数
至于 具体如何跳过，后面会讲到，先从原因出发

如下图所示：s[7]与P[7]匹配失败之后
经过四轮‘第一个字符不匹配’的比较（这四轮就是不可能匹配的字符串）

如图所示：在第一轮失配后，直至模式串P移动到这个位置时，第一个字符才相同

而我们发现，AC在模式串中前后出现了两次，并且两次是连续匹配成功的（连续！！）
即中间似乎可以跳过

我们将这个初步设想展开
首先，如图，由多次匹配失败可知，主串的某一个子串等于模式串的某一个前缀。
那在这一子串中，如果我们可以找到相同前后缀，则在匹配失败后的下一次匹配中，就可以通过 将前缀移动到原本后缀的位置 ，以跳过不可能匹配的字符串

*相同前后缀：字符串的前k个字符==字符串的后k个字符 （k<字符串长度）

具体的跳过需要根据next数组

解决方法

next数组

核心思想： “P自己与自己做匹配”
next数组 含义
next数组是对于模式串而言的。
P 的 next 数组定义为：next[i] 表示 P[0] ~ P[i] 这一个子串，使得前k个字符恰等于后k个字符 的最大的k
k-前缀： 为一个字符串的前k个字符
k-后缀： 为一个字符串的后k个字符
（k<字符串长度）

求出next数组
假设：已知 next[0], next[1], … next[x-1]
现求： next[x]

围绕 p[x] =p[now] 使得 next[x]= now+1 来求 next[x]

i) p[x] = p[now] (定义 now = next[x-1])
即 P[0] ~ P[x-1] 子串中，前next[x-1]( = now)个字符恰等于后next[x-1]( = now)个字符，
也就是子串 P[0] ~ P[now-1] = P[x-now] ~ P[x-1]。
现要检查P[0]~P[x]中前k个字符恰等于后k个字符 的最大的k，即next[x]

如果 P[x] 与 P[now] 一样，那最长相等前后缀的长度就可以扩展一位，

next[x] = now + 1

ii) p[x] != p[now]

我们只能通过“在p[x]=p[now]的情况下 ，有 next[x] = now+1" 来求next[x]
但是 p[x] != p[now]，因此缩短前后缀的长度，即缩小now 直至 p[x] = p[now]

now 是最长的公共前后缀子串A/B的长度。找到P[0]~P[x-1]中更小的前后缀，即缩小now。再检查P[now]=P[x]? 取第一次满足P[now]=P[x]的now值，使得now最大。

即在保持“P[0]~P[x-1]的now-前缀仍然等于now-后缀”的前提下，使得now最大

缩减后，前缀 仍落在A中，后缀仍落在B中，即A的k-前缀 = B的k-后缀的最大的k。然而，子串A = 子串B，即我们要找的 A的k-前缀 = A的k-后缀的最大的k.

A的k-前缀 = A的k-后缀 的最大的k ,不就是 next[now-1]吗
（由于：next[x]= now+1）

因此 next[x] = next[now-1] +1;

综上所述
i) p[x] = p[now]
next[x] = now + 1
ii) p[x] != p[now]
next[x] = next[now-1] +1

求next数组的代码

        int m = S.size();
    	int n = P.size();
		int x = 1;//从next[1]开始求
        int now = 0;
        vector<int> next(n,0);
        next.push_back(0);//next[0]肯定是0
        while(x < n){
           if(P[x] == P[now]){
           		next.push_back(now + 1)
           		x++;
           		}
           else if(now)//缩短now的长度 
           		now = next[now-1];
           else{ //now=0
           		next.push_back(0);
           		x++;
           		}
        }

AC代码

class Solution {
public:
    int strStr(string haystack, string needle) {
    //求next
    	int m = haystack.size();
    	int n = needle.size();
		int x = 1;//从next[1]开始求
        int now = 0;
        vector<int> next(n,0);
        next.push_back(0);//next[0]肯定是0
        while(x < n){
           if(needle[x] == needle[now]){
           		next.push_back(now + 1);
           		x++;
           		now++;
           		}
           else if(now)//缩短now的长度 
           		now = next[now-1];
           else{ //now=0
           		next.push_back(0);
           		x++;
           		}
        }
        //开始比较
        int i = 0, j= 0;
        while(i < m && j < n){ //i指向主串 j指向模式串
        if(haystack[i] == needle[j]){ //匹配成功，则都向后移一位
        	i++;
        	j++;
    	}
    	else if(j)//匹配失败，此时j!=0，根据next移动模式串
    		j = next[j-1];
    	else//needle[0]与haystack[i]匹配失败，将模式串向右移一位
    		i++;
    	}
//匹配结束，现在来看结果
		if(j == n) //j=n 则匹配成功
			return i-j;
		return -1;
}
};

解法二的AC代码
// 这是另外一个方法的解法，详情请看我另外一篇blog

class Solution 
{
public:
    int strStr(string haystack, string needle) 
    {
        if(needle.size() == 0)
            return 0;
        int i = -1, j = 0;
        vector<int> next(needle.size(),0);
        next[0] = -1;
        //第一部分 next
        while(j < needle.size() - 1)
        {
            //j是指向needle中的字符，固定住，再与i指向的字符比较
            //i也是指向needle中的字符，但是若与j指向的不相同，则会回溯到第一个
            if(i < 0 || needle[i] == needle[j])//i<0表示从needle头开始找最长前后缀
            {
                j++;
                i++;
                next[j] = i;
            }//若前面几个字符都不匹配，会发现i在0和1之间不停转变
            //不匹配，则j就向下一个移动
            else
                i = next[i];//若不匹配，则将i回溯（注意：不一定是第一个字符）
        }
        //第二部分 开始比较
        int n = haystack.size();
        int m = needle.size();
        //string.size() 返回值的类型是unsigned long
        //所以必须调用新变量 才能在后面与 i，j（signed int）进行比较
        i = 0, j = 0;
        while(i < n && j < m)
        {
            if(j < 0 || haystack[i] == needle[j])//j<0表示从needle的第一个字符进行比较
            {
                i++;
                j++;
            }
            else
                j = next[j];  //比较不相同 则将j回溯到前缀后第一个字符的位置
        }
        if( j == m)
            return i-j; //j为needle的长度 i-j则为在haystack中 needle第一次出现的位置
        return -1;
    }
};