KMP算法
作用:应用在字符串匹配中。
主要思想:当出现字符串不匹配时,利用已知的已匹配的文本内容,避免从头匹配。
重点:在KMP算法中使用next数组记录已经匹配的文本内容。
什么是前缀表?记录下标i(包括i)的字符串中,有多大长度的相同前后缀。
next数组就是一个前缀表,利用前缀表进行回退,其记录了模式串和文本串不匹配时,模式串用从哪个位置开始重新匹配。
例:要在文本串:aabaabaafa中查找是否出现过一个模式串:aabaaf
![](https://img-blog.csdnimg.cn/img_convert/46dd6f9c3b9eda15dd846ae23d7d1246.png)
如上图所示:文本串中第六个字符b和模式串f不匹配,如果暴力匹配,则需要从头开始匹配;若使用前缀表,就不会从头匹配,而是从上次已经匹配的内容开始匹配,找到模式串中第三个字符b继续开始匹配。那么前缀表是如何记录的呢?前缀表的任务是当前位置匹配失败,找到之前已经匹配上的位置,再重新匹配,也就意味着再某个字符不匹配时,前缀表会告诉你下一步匹配中,模式串应该跳到哪个位置。
前缀与后缀
前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串;
后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串。
前缀表要求的就是相同前后缀的长度。
例:在匹配的过程中,在下标5的地方遇到不匹配,模式串指向5;
![](https://img-blog.csdnimg.cn/img_convert/9dedc7c2ec2c0fec49e36fc8adccff05.png)
然后找到了下标2,指向b,继续匹配
![](https://img-blog.csdnimg.cn/img_convert/31a27ab67c42d66a8cad81e9646bf550.png)
下标5之前的这部分字符串(aabaa)的最长相等的前缀和后缀字符串是子字符串aa,因为找到了最长相等的前缀和后缀,匹配失败的位置是后缀子串的后面,那么我们找到了与其相同的前缀得到后面重新匹配即可。
如何计算前缀表
例:aabaaf
![](https://img-blog.csdnimg.cn/img_convert/ac2a1b11217f4c04a0f1ca59fbb02f31.png)
长度为前1个字符的子串a,最长相同前后缀的长度为0;
![](https://img-blog.csdnimg.cn/img_convert/b3e56b416955f06759d560a181367f26.png)
长度为前2个字符的子串aa,最长相同的前后缀的长度为1;前缀a 后缀 a
![](https://img-blog.csdnimg.cn/img_convert/d02a30c0a5a24734d8a9b43f4a2d65c1.png)
长度为前3个字符的子串aab,最长相同的前后缀的长度为0;前缀:a,aa 后缀 ab,b
(前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串;后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串。)
以此类推,长度为前4个字符的子串aaba,最长相同的前后缀长度为1(前缀:a,aa,aab后缀:aba,ba,a);长度为前5个字符的子串aabaa,最长相同的前后缀长度为2(前缀:a,aa,aab,aaba后缀:abaa,baa,aa,a);长度为前6个字符的子串aabaaf(前缀:a,aa,aab,aaba,aabaa后缀:abaaf,baaf,aaf,af,f),最长相同的前后缀长度为0;
于是,求得最长相同前后缀长度就是对于前缀表的元素,如下图:
![](https://img-blog.csdnimg.cn/img_convert/e13cc15575fdb64453556212dad8f51f.png)
前缀表与next数组
next数组就可以是前缀表,但是很多实现都是把前缀表统一减一(右移一位,初始位置为-1)之后作为next数组。其实这并不涉及到KMP的原理,而是具体实现,next数组既可以就是前缀表,也可以是前缀表统一减一(右移一位,初始位置为-1)。
使用next数组匹配
![](https://img-blog.csdnimg.cn/img_convert/14af5ddf49ae72e787e1e82a69210538.png)
时间复杂度分析
其中n为文本串长度,m为模式串长度,因为在匹配的过程中,根据前缀表不断调整匹配的位置,可以看出匹配的过程是O(n),之前还要单独生成next数组,时间复杂度是O(m)。所以整个KMP算法的时间复杂度是O(n+m)的。
构造next数组
定义一个函数getNext来构建next数组,函数参数为指向next数组的指针,和一个字符串。 代码如下:
void getNext(int* next, const string& s)
构造next数组其实就是计算模式串s,前缀表的过程。 主要有如下三步:
初始化
处理前后缀不相同的情况
处理前后缀相同的情况
初始化:
定义两个指针i和j,j指向前缀末尾的位置,i指向后缀末尾的位置。
对next数组进行初始化赋值,如下:
int j =-1;
next[0]= j;
next[i] 表示 i(包括i)之前最长相等的前后缀长度(其实就是j)
处理前后缀不相同的情况
因为j初始化为-1,那么i就从1开始,进行s[i]与s[j+1]的比较。
使用遍历模式串是s的下标i要从1开始,代码如下:
for(int i =1; i < s.size(); i++){
如果 s[i] 与 s[j+1]不相同,也就是遇到 前后缀末尾不相同的情况,就要向前回退。
怎么回退呢?
next[j]就是记录着j(包括j)之前的子串的相同前后缀的长度。
那么 s[i] 与 s[j+1] 不相同,就要找 j+1前一个元素在next数组里的值(就是next[j])。
所以,处理前后缀不相同的情况代码如下:
while(j >=0&& s[i]!= s[j +1]){// 前后缀不相同了
j = next[j];// 向前回退
}
处理前后缀相同的情况
如果 s[i] 与 s[j + 1] 相同,那么就同时向后移动i 和j 说明找到了相同的前后缀,同时还要将j(前缀的长度)赋给next[i], 因为next[i]要记录相同前后缀的长度。
if (s[i] == s[j + 1]) { // 找到相同的前后缀
j++;
}
next[i] = j;
![](https://img-blog.csdnimg.cn/img_convert/bcccaa30da88c769d9d2aedc1cd0a132.gif)
使用next数组做匹配
在文本串s里找是否出现过模式串t。
定义两个下标j 指向模式串起始位置,i指向文本串起始位置。
那么j初始值依然为-1,为什么呢? 依然因为next数组里记录的起始位置为-1。
i就从0开始,遍历文本串,代码如下:
for(int i =0; i < s.size(); i++)
接下来就是 s[i] 与 t[j + 1] (因为j从-1开始的) 进行比较。
如果 s[i] 与 t[j + 1] 不相同,j就要从next数组里寻找下一个匹配的位置。
代码如下:
while(j >=0&& s[i]!= t[j +1]){
j = next[j];}
如果 s[i] 与 t[j + 1] 相同,那么i 和 j 同时向后移动, 代码如下:
if(s[i]== t[j +1]){
j++;// i的增加在for循环里
}
如何判断在文本串s里出现了模式串t呢,如果j指向了模式串t的末尾,那么就说明模式串t完全匹配文本串s里的某个子串了。
本题要在文本串字符串中找出模式串出现的第一个位置 (从0开始),所以返回当前在文本串匹配模式串的位置i 减去 模式串的长度,就是文本串字符串中出现模式串的第一个位置。
if(j ==(t.size()-1)){
return(i - t.size()+1);
}
haystack为文本串, needle为模式串。
28. 找出字符串中第一个匹配项的下标 - 力扣(LeetCode)
class Solution {
public:
void getNext(int* next, const string& s){
int j = -1;
next[0]=j;
for(int i =1;i<s.size();i++){
while(j>=0&&s[i]!=s[j+1]){
j=next[j];
}
if(s[i]==s[j+1]){
j++;
}
next[i]=j;
}
}
int strStr(string haystack, string needle) {
if(needle.size()==0){
return 0;
}
int next[needle.size()];
getNext(next, needle);
int j = -1;
for(int i=0;i<haystack.size();i++){
while(j>=0&&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;
}
};
移动匹配
当一个字符串s:abcabc,内部由重复的子串组成,那么这个字符串的结构一定是这样的:
![](https://img-blog.csdnimg.cn/img_convert/7f25f84b9fbfe6629271025512f4db38.png)
也就是由前后相同的子串组成。
那么既然前面有相同的子串,后面有相同的子串,用 s + s,这样组成的字符串中,后面的子串做前串,前后的子串做后串,就一定还能组成一个s,如图:
![](https://img-blog.csdnimg.cn/img_convert/df37eb9ba0f4c393370d3f16b42247cc.png)
所以判断字符串s是否由重复子串组成,只要两个s拼接在一起,里面还出现一个s的话,就说明是由重复子串组成。
当然,我们在判断 s + s 拼接的字符串里是否出现一个s的的时候,要刨除 s + s 的首字符和尾字符,这样避免在s+s中搜索出原来的s,我们要搜索的是中间拼接出来的s。
class Solution {
public:
bool repeatedSubstringPattern(string s) {
string t = s+s;
t.erase(t.begin());
t.erase(t.end()-1);
if(t.find(s)!=std::string::npos) return true;
return false;
}
};
在由重复子串组成的字符串中,最长相等前后缀不包含的子串就是最小重复子串,这里拿字符串s:abababab 来举例,ab就是最小重复单位,如图所示:
![](https://img-blog.csdnimg.cn/img_convert/2ac446360b6eb37805667a127200338e.png)
如何找到最小重复子串
![](https://img-blog.csdnimg.cn/img_convert/f40b26abba3b40ddd7fb37b61121fa28.png)
步骤一:因为 这是相等的前缀和后缀,t[0] 与 k[0]相同, t[1] 与 k[1]相同,所以 s[0] 一定和 s[2]相同,s[1] 一定和 s[3]相同,即:,s[0]s[1]与s[2]s[3]相同 。
步骤二: 因为在同一个字符串位置,所以 t[2] 与 k[0]相同,t[3] 与 k[1]相同。
步骤三: 因为 这是相等的前缀和后缀,t[2] 与 k[2]相同 ,t[3]与k[3] 相同,所以,s[2]一定和s[4]相同,s[3]一定和s[5]相同,即:s[2]s[3] 与 s[4]s[5]相同。
步骤四:循环往复。
所以字符串s,s[0]s[1]与s[2]s[3]相同, s[2]s[3] 与 s[4]s[5]相同,s[4]s[5] 与 s[6]s[7] 相同。
正是因为 最长相等前后缀的规则,当一个字符串由重复子串组成的,最长相等前后缀不包含的子串就是最小重复子串。
简单推理
假设字符串s使用多个重复子串构成(这个子串是最小重复单位),重复出现的子字符串长度是x,所以s是由n * x组成。
因为字符串s的最长相同前后缀的长度一定是不包含s本身,所以 最长相同前后缀长度必然是m * x,而且 n - m = 1,所以如果 nx % (n - m)x = 0,就可以判定有重复出现的子字符串。next 数组记录的就是最长相同前后缀, 如果 next[len - 1] != -1,则说明字符串有最长相同的前后缀(就是字符串里的前缀子串和后缀子串相同的最长长度)。
数组长度为:len。
如果len % (len - (next[len - 1] + 1)) == 0 ,则说明数组的长度正好可以被 (数组长度-最长相等前后缀的长度) 整除 ,说明该字符串有重复的子字符串。
数组长度减去最长相同前后缀的长度相当于是第一个周期的长度,也就是一个周期的长度,如果这个周期可以被整除,就说明整个数组就是这个周期的循环。
![](https://img-blog.csdnimg.cn/img_convert/49e0d216762e5b862663378b5be11ed0.png)
next[len - 1] = 7,next[len - 1] + 1 = 8,8就是此时字符串asdfasdfasdf的最长相同前后缀的长度。
(len - (next[len - 1] + 1)) 也就是: 12(字符串的长度) - 8(最长公共前后缀的长度) = 4, 4正好可以被 12(字符串的长度) 整除,所以说明有重复的子字符串(asdf)。
class Solution {
public:
void getNext (int* next, const string& s){
next[0] = -1;
int j = -1;
for(int i = 1;i < s.size(); i++){
while(j >= 0 && s[i] != s[j + 1]) {
j = next[j];
}
if(s[i] == s[j + 1]) {
j++;
}
next[i] = j;
}
}
bool repeatedSubstringPattern (string s) {
if (s.size() == 0) {
return false;
}
int next[s.size()];
getNext(next, s);
int len = s.size();
if (next[len - 1] != -1 && len % (len - (next[len - 1] + 1)) == 0) {
return true;
}
return false;
}
};
(判断条件要想清楚)