//读 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;
}
};