代码随想录算法训练营第9天 KMP算法 | 28.找到字符串中第一个匹配项的下标 459.重复的子字符串

KMP算法

  • 简介:解决字符串匹配问题,用模式串 p 匹配文本串 T。暴力匹配的时间复杂度是 O(mxn)。KMP 算法是针对暴力匹配算法的一次巧妙的改进。核心思想就是将匹配失败的信息利用起来,减少回退的次数,使文本串的指针可以始终向前推进。所以如何利用失败信息呢?
  • 具体实现步骤:当文本串第k+1个元素匹配失败时,我们知道前面k个字符都是匹配上了的,即P[0:k] = T[q:q+k](左闭右开区间)。这里面是有信息可以使用的,我们可以尝试找到P[0:k]中最长的前缀0 ~ j,满足与后缀k-j ~ k相同,那就可以只回退模式串指针来比较P[j+1]T[q+k],如果相等比较继续进行,如果失败继续回退模式串。
  • next 数组:这样就需要维护一个能指示回退位置的 next 数组,注意这个数组仅与模式串有关,可以在执行匹配前实现好。next 数组是前缀表,存储的是模式串的不同子串所具有的相同前后缀的最大长度注意前缀表的作用是当前位置匹配失败时,指示模式串指针应回退到哪个位置。
    代码随想录算法训练营第9天 KMP算法 | 28.找到字符串中第一个匹配项的下标 459.重复的子字符串_第1张图片
  • 关于前后缀的定义:前缀是不包含最后一个字符的所有以第一个字符开头的连续子串;后缀是不包含第一个字符的所有以最后一个字符结尾的连续子串。
  • 时间复杂度分析:KMP 算法中文本串的指针是始终向前的,即 O(n)。但是获得 next 数组需要额外的开销,因此总体时间复杂度为 O(m+n)。
  • next 数组的获取。可以使用 left、right 双指针来实现,初始时left = 0, right = 1。left 代表相同前缀的最后位置,right 代表后缀的最后位置,同时 left 也是相等前后缀的长度。
    如果p[left] != p[right],那就需要回退 left,这与字符串匹配失败是类似的,我们要尽量保留已经确定相等的前后缀(利用已经匹配的信息),所以我们使用相同的方式回退即可(循环过程的不变量);如果二者相等,left 向后更新一个位置。
    由以上的分析可知,left 之前都是已经确定的相等前缀,即 p[0, left) = p[right-left, right)。当不相等发生时,我们要利用已经匹配的信息,从 p[0, left) 中选择最长前缀使之与 p[right-left, right) 的后缀相等。具体做法是若 j = next[left- 1],即p[0, j) = p[left-j, left) = p[right-j, right),我们就又找到了一段长为 j 的已经判断相等的前后缀,继续比较 p[j] 和 p[right] 就可以了。
class Solution{
public:
	void getNext(int* next, string s){
		int left = 0;
		next[0] = left;
		for(int right = 1; right < s.size(); right++){
			while(left > 0 && s[left] != s[right]){
				left = next[left - 1];
			}
			if(s[left] == s[right]){
				left++;
			}
			next[right] = left;
		}
	}
	int strStr(string haystack, string needle){
		int i = 0;  // 文本串指针
		int j = 0;  // 模式串指针
		int next[needle.size()];
		getNext(next, needle);
		for(; i < haystack.size(); i++){
			while(j > 0 && haystack[i] != needle[j]){
				j = next[j - 1];
			}
			if(haystack[i] == needle[j]){
				j++;
			}
			if(j == needle.size()){
				return (i - needle.size() + 1);
			}
		}
		return -1;
	}
};

有一些实现中,next 数组取值为前缀表整体减1,其实和这种原封不动使用前缀表的实现相比,原理是一样的,只是 KMP 算法不同的实现而已。但要注意回退时的下标与遍历时的下标,整体减1的实现中,在比较时模式串指针应该在 j+1 的位置,回退时则不需要进行 j-1 的操作,j = next[j]

class Solution{
public:
	void getNext(int* next, string s){
		int left = -1;
		next[0] = left;
		for(int right = 1; right < s.size(); right++){
			while(left > -1 && s[left + 1] != s[right]){
				left = next[left];
			}
			if(s[left + 1] == s[right]){
				left++;
			}
			next[right] = left;
		}
	}
	int strStr(string haystack, string needle){
		int i = 0;  // i为文本串指针
		int j = -1;  // j+1为模板串指针
		int next[needle.size()];
		getNext(next, needle);
		for(; i < haystack.size(); i++){
			while(j > -1 && haystack[i] != needle[j+1]){
				j = next[j];
			}
			if(haystack[i] == needle[j+1]){
				j++;
			}
			if(j == needle.size() - 1){
				return (i - needle.size() + 1);
			}
		}
		return -1;
	}
};

重复的子字符串

代码随想录算法训练营第9天 KMP算法 | 28.找到字符串中第一个匹配项的下标 459.重复的子字符串_第2张图片
我们当然可以想到暴力解法,即遍历不同长度的前缀,使之与 s 进行匹配,由于子串需要重复,这里我们只需要遍历能被s.size()整除的长度,并且只需要遍历到 s 长度的一半位置。
上面算法的时间复杂度基本就是 O(n^2)。

移动匹配

代码随想录算法训练营第9天 KMP算法 | 28.找到字符串中第一个匹配项的下标 459.重复的子字符串_第3张图片
如果一个字符串可以由重复的子串组成,那么当两个这样相同的字符串 s 拼接成一个新字符串 t=s+s 时,一定可以在掐头去尾的 t 中找到原字符串 s,也就是肯定可以由原字符串的后缀和前缀拼出一个原字符串。

class Solution{
public:
	bool repeatedSubstringPattern(string s){
		string t = s + s;
		t.erase(t.begin());
		t.erase(t.begin() + t.size() - 1);
		if(t.find(s) == std::string::npos)  return false;
		return true;
	}
};

库函数find()的时间复杂度为 O(m+n),不一定是 KMP 算法。本方法的时间复杂度为 O(n)。

KMP 算法实现

KMP 算法本来是用来进行字符串匹配的,与确定重复子串有什么关系呢?先说结论:在重复子串组成的字符串中,最长相等前后缀不包含的子串就是最小重复子串。
我们知道当前位置匹配失败时,KMP 算法通过 next 数组来确定回退位置。next 数组就是前缀表,里面是以各个位置为终点的子字符串的最长相等前后缀的长度。如下图所示,最长相等前后缀的性质使得不被包含的子串可以递推地传递下去。
代码随想录算法训练营第9天 KMP算法 | 28.找到字符串中第一个匹配项的下标 459.重复的子字符串_第4张图片
这样就容易判断了,如果不包含的子串长度可以整除原字符串的长度,证明原字符串可以由不包含的子串重复组成。

class Solution{
public:
	bool repeatedSubstringPattern(string s){
		int len = s.size();
		int next[len];
		int left = 0;
		next[0] = left;
		for(int right = 1; right < s.size(); right++){
			while(left > 0 && s[left] != s[right]){
				left = next[left - 1];
			}
			if(s[left] == s[right]){
				left++;
			}
			next[right] = left;
		}
		return next[len - 1] != 0 && len % (len - next[len - 1]) == 0;
	}
};

你可能感兴趣的:(算法)