没错,博主又开始学算法了。。。话说我以前不是叫自己猴子吗?
还是那句话,因为是个人的感受与体验,所以写上原创。
目录
- kmp简介
- kmp的过程
- 例题与练习题
- kmp的优化
- 小结(这次竟然有小结!)
kmp简介
平常我们字符串匹配,暴力 O ( n m ) O(nm) O(nm)是不是感觉自己已经可以称霸全世界了?
不是!还有STL
STL的大佬就不要看我这种蒟蒻的博客了。
当然,时间慢自然会有大佬去开发一种算法来加速。
就是他们,研究出了kmp 看毛片算法。
sto,sto,sto
注:作者字符串均从下标为1开始
kmp的过程
kmp的思想是什么?
建一个kmp数组, k m p i kmp_{i} kmpi代表在一个字符串中 [ i − k m p i + 1 , i ] [i-kmp_{i}+1,i] [i−kmpi+1,i]与 [ 1 , k m p i ] [1,kmp_{i}] [1,kmpi]是匹配的。(注意, k m p i ≠ i kmp_{i}\ne i kmpi̸=i)。
那么,当我们知道了
k
m
p
i
kmp_{i}
kmpi如何求出
k
m
p
i
+
1
kmp_{i+1}
kmpi+1?
(设字符串为
s
s
ss
ss数组)
- 如果 s s [ k m p i + 1 ] = s s [ i + 1 ] ss[kmp_{i}+1]=ss[i+1] ss[kmpi+1]=ss[i+1]那么 k m p i + 1 = k m p i + 1 kmp_{i+1}=kmp_{i}+1 kmpi+1=kmpi+1,这一步很简单。
- 如果
s
s
[
k
m
p
i
+
1
]
≠
s
s
[
i
+
1
]
ss[kmp_{i}+1]\ne ss[i+1]
ss[kmpi+1]̸=ss[i+1],那怎么办?
k
m
p
i
+
1
=
0
kmp_{i+1}=0
kmpi+1=0,然后重新循环一遍匹配?
不不不,想想kmp数组的定义,一个字符串中 [ i − k m p i + 1 , i ] [i-kmp_{i}+1,i] [i−kmpi+1,i]与 [ 1 , k m p i ] [1,kmp_{i}] [1,kmpi]是匹配的,我们不能让这一个重要的资源浪费了。
匹配过程:
最后我们就匹配成功了。
所以,当
s
s
[
k
m
p
i
+
1
]
≠
s
s
[
i
+
1
]
ss[kmp_{i}+1]\ne ss[i+1]
ss[kmpi+1]̸=ss[i+1]时,我们可以设
n
o
w
=
k
m
p
i
now=kmp_{i}
now=kmpi
然后不断匹配,匹配不成功就让
n
o
w
=
k
m
p
n
o
w
now=kmp_{now}
now=kmpnow,我们可以设
k
m
p
0
=
−
1
kmp_{0}=-1
kmp0=−1当
s
s
[
k
m
p
i
+
1
]
=
s
s
[
i
+
1
]
ss[kmp_{i}+1]=ss[i+1]
ss[kmpi+1]=ss[i+1]或
n
o
w
=
−
1
now=-1
now=−1时退出,同时用
k
m
p
i
+
1
=
n
o
w
+
1
kmp_{i+1}=now+1
kmpi+1=now+1。
其实第一个也可以这么做,因为当
n
o
w
=
k
m
p
i
now=kmp_{i}
now=kmpi时就已经退出了,所以
k
m
p
i
+
1
=
n
o
w
+
1
=
k
m
p
i
+
1
kmp_{i+1}=now+1=kmp_{i}+1
kmpi+1=now+1=kmpi+1。
我们可以先处理出子串的kmp数组,那么怎么做?
设
i
i
i为当前已经匹配到的母串的位置,那么设now代表母串中
[
i
−
n
o
w
+
1
,
n
o
w
]
[i-now+1,now]
[i−now+1,now]与子串的
[
1
,
n
o
w
]
[1,now]
[1,now]完全匹配,那么的话,就像建立kmp数组那样,以母串的第
i
i
i个位置now来处理出
i
+
1
i+1
i+1的位置的now。
至于具体过程,跟处理kmp数组那样,换汤不换药,自己想。
就是你懒!
而这里,就是判断当 n o w = now= now=子串的长度时, a n s + + , n o w = 0 ans++,now=0 ans++,now=0。
注:这里的kmp数组许多人都失败
(
f
a
i
l
)
(fail)
(fail)数组。
注意,不能让
k
m
p
i
=
i
kmp_{i}=i
kmpi=i
#include<cstdio>
#include<cstring>
#include<cstdlib>
using namespace std;
char s1[2100],s2[2100];//字符串
int kmp[2100],ans,n,m;//kmp数组
int main()
{
while(1)
{
scanf("%s",s1+1);n=strlen(s1+1);
if(n==1 && s1[1]=='#')break;//判断
scanf("%s",s2+1);m=strlen(s2+1);//输入
kmp[0]=-1;ans=0;//一种让kmp[i]!=i的方法
int now;
for(int i=1;i<=m;i++)//子串
{
now=kmp[i-1];
while(now>-1 && s2[i]!=s2[now+1])now=kmp[now];
kmp[i]=now+1;
}
now=0;
for(int i=1;i<=n;i++)//母串匹配
{
while(now>-1 && s1[i]!=s2[now+1])now=kmp[now];
now++;
if(now==m)ans++,now=0;//统计答案
}
printf("%d\n",ans);
}
return 0;
}
例题与练习题
这道题,用kmp做的话,仔细观察,发现如果 n   m o d   ( n − k m p n ) = = 0 n\bmod (n-kmp_{n})==0 nmod(n−kmpn)==0,那么 n − k m p n n-kmp_{n} n−kmpn就是循环节,否则不存在循环节。
Why?
首先,如果
k
m
p
n
<
(
n
+
1
)
/
2
kmp_{n}<(n+1)/2
kmpn<(n+1)/2那么
n
 
m
o
d
 
(
n
−
k
m
p
n
)
≠
0
n\bmod (n-kmp_{n})\ne 0
nmod(n−kmpn)̸=0
因此我们不讨论这种情况。
如图:
注:这里a1-a10代表字符串的前缀,b1-b10是字符串的后缀
那我们现在需要证明当
n
 
m
o
d
 
(
n
−
k
m
p
n
)
≠
0
n\bmod (n-kmp_{n})\ne 0
nmod(n−kmpn)̸=0时没有循环节。
反证法:
如果有,设循环节长度为
k
k
k,然后设
k
m
p
n
%
k
=
t
t
kmp_{n}\%k=tt
kmpn%k=tt。
那么:
所以这种方法可以行得通,耶!
代码:
#include<cstdio>
#include<cstring>
using namespace std;
char ss[2100000];
int kmp[2100000],n;
int main()
{
while(1)
{
scanf("%s",ss+1);n=strlen(ss+1);
if(n==1 && ss[1]=='.')break;//判断
kmp[0]=-1;
int now=0;
for(int i=1;i<=n;i++)//建造kmp数组
{
now=kmp[i-1];
while(now>-1 && ss[now+1]!=ss[i])now=kmp[now];
kmp[i]=now+1;
}
if(n%(n-kmp[n])==0)printf("%d\n",n/(n-kmp[n]));//判断
else printf("1\n");
}
return 0;
}
这道题,我们这次只要输出n-kmp[n]就行了。。。
首先在这道题中,如果abc是循环节,那么bca、cab也是循环节,也就是谁从开头求循环节或从结尾求循环节得出的长度是一样的,那么像上次那样
n
−
k
m
p
n
n-kmp_{n}
n−kmpn?
答案是肯定的,假设从结尾求得循环节是
a
1
a
2
a
3
.
.
.
a
k
a_{1}a_{2}a_{3}...a_{k}
a1a2a3...ak而字符串则是
a
i
a
i
+
1
.
.
.
a
k
a
1
a
2
.
.
.
a
k
.
.
.
a_{i}a_{i+1}...a_{k}a_{1}a_{2}...a_{k}...
aiai+1...aka1a2...ak...。那么
k
m
p
n
kmp_{n}
kmpn除了像上次那样统计了循环节外,还统计了开头
a
i
a
i
+
1
.
.
.
a
k
a_{i}a_{i+1}...a_{k}
aiai+1...ak的部分,所以拿
n
−
k
m
p
n
n-kmp_{n}
n−kmpn刚好就是循环节的长度,而且因为题意,我们不用担心无解的情况,直接输出就好了。
#include<cstdio>
#include<cstring>
using namespace std;
int kmp[1100000],n;
char st[1100000];
int main()
{
scanf("%d",&n);
scanf("%s",st+1);
kmp[0]=-1;
for(int i=1;i<=n;i++)//统计kmp数组
{
int now=kmp[i-1];
while(now!=-1 && st[i]!=st[now+1])now=kmp[now];
kmp[i]=now+1;
}
printf("%d\n",n-kmp[n]);//输出
return 0;
}
将题意转成人话:
求字符串A的所有前缀AA,定义最长的不断复制自己再接到后面能够覆盖前缀AA且不等于AA的字符串为AA的周期(周期可以是空串),如abababab,ababab通过不断复制自己再接到后面形成abababababab…能够覆盖abababab,且ababab的长度是最长的,求所有前缀AA的周期长度总和。
这道题,就是要我们求出每个前缀的最长循环节,跟上题差不多,不过找的方式变了。
从前往后找与从后往前找的最长循环节长度一样。
那么我们考虑题意是接到不断复制接到前面,那么我们可以知道
而且通过上一道题,我们可以知道,这里的红色块就是上一道题的循环节,而循环节就是 n o w − k m p n o w now-kmp_{now} now−kmpnow,我们就可以不断用 n o w % ( n o w − k m p n o w ) now\%(now-kmp_{now}) now%(now−kmpnow)来处理出黄色块的长度,然后用前缀AA的长度减去黄色块的长度,就是最长循环节的长度了。
当然也有细节:
- 当 k m p n o w = 0 kmp_{now}=0 kmpnow=0时退出。
- 在模的过程,别忘了当now=0时,now= ( n o w − k m p n o w ) (now-kmp_{now}) (now−kmpnow)。(特判没有黄色块的情况。)
优化:当 k m p i ≠ 0 kmp_{i}\ne 0 kmpi̸=0时,我们可以用 k m p i = 前 缀 1 − > i 的 黄 色 块 的 长 度 kmp_{i}=前缀1->i的黄色块的长度 kmpi=前缀1−>i的黄色块的长度,省去以后找的次数。
#include<cstdio>
#include<cstring>
using namespace std;
int kmp[1100000],n;
char st[1100000];
int main()
{
scanf("%d",&n);
scanf("%s",st+1);
kmp[0]=-1;
for(int i=1;i<=n;i++)//kmp
{
int now=kmp[i-1];
while(now!=-1 && st[i]!=st[now+1])now=kmp[now];
kmp[i]=now+1;
}
long long ans=0;
for(int i=1;i<=n;i++)
{
int now=i;
while(kmp[now])//处理黄色块的长度
{
int gtk=kmp[now];
now%=gtk;
if(now==0)now=gtk;//特判
}
if(kmp[i]!=0)kmp[i]=now;//优化
ans+=i-now;//统计
}
printf("%lld\n",ans);//输出
return 0;
}
当然,有的大佬为了让过程简洁,用另一种方法,思想一样,方法不同。
每次跳 k m p n o w kmp_{now} kmpnow,当 k m p n o w = 0 kmp_{now}=0 kmpnow=0时退出,至于为什么正确,参考上面的题目与kmp数组的定义。
优化也可以用到哟。
#include<cstdio>
#include<cstring>
using namespace std;
int kmp[1100000],n;
char st[1100000];
int main()
{
scanf("%d",&n);
scanf("%s",st+1);
kmp[0]=-1;
for(int i=1;i<=n;i++)//kmp数组处理
{
int now=kmp[i-1];
while(now!=-1 && st[i]!=st[now+1])now=kmp[now];
kmp[i]=now+1;
}
long long ans=0;
for(int i=1;i<=n;i++)
{
int now=i;
while(kmp[now])now=kmp[now];//找到黄色块的长度
if(kmp[i]!=0)kmp[i]=now;
ans+=i-now;//统计答案。
}
printf("%lld\n",ans);//输出
return 0;
}
人话。。。
统计字符串中由A+B+A构成的字符子串的个数,且|A|≥k,|B|≥1,且一个划分不同但区域相同的算同一子串。
如aaaaa,可以分成A=“aa”,B="a"或A=“a”,B=“aaa”,但是只算一个。
枚举左端点,跑左端点至n的kmp,然后暴力枚举右端点, O ( n 2 ) O(n^{2}) O(n2)可以过!
不过如何判断一个区间是否符合?
设 n o w = k m p r now=kmp_{r} now=kmpr,然后判断l->now的长度符不符合要求,不符合继续让 n o w = k m p n o w now=kmp_{now} now=kmpnow,符合,统计答案,退出。
可能说的不好。。。看代码然后自行理解。
#include<cstdio>
#include<cstring>
using namespace std;
int kmp[21000],n,m,ans;
char st[21000];
int main()
{
scanf("%s",st+1);n=strlen(st+1);//输入
scanf("%d",&m);
for(int i=1;i<=n;i++)
{
kmp[i-1]=i-2;//像kmp[0]=-1的操作
for(int j=i;j<=n;j++)
{
int now=kmp[j-1];
while(now!=i-2 && st[now+1]!=st[j])now=kmp[now];//处理kmp数组
kmp[j]=++now;now=j;
if(i+2*m<=j)//i+2*m-1+1,先判断可不可能存在这样的子串
{
while(kmp[now]>=i+m-1)//判断条件
{
if(kmp[now]<=(i+j)/2-1)//判断是否是A+B+A的形式
{
ans++;//统计,退出
break;
}
now=kmp[now];//继续判断
}
}
}
}
printf("%d\n",ans);//输出
return 0;
}
一个栈储存目前没有被删除的字符串,然后。。。
#include<cstdio>
#include<cstring>
using namespace std;
char s1[1100000]/*母串*/,s2[1100000]/*子串*/,st[1100000]/*栈*/;//字符串
int kmp[1100000],dt[1100000],n,m,len;//kmp数组
int main()
{
scanf("%s%s",s1+1,s2+1);n=strlen(s1+1);m=strlen(s2+1);//输入
kmp[0]=-1;//
for(int i=1;i<=m;i++)
{
int now=kmp[i-1];
while(now!=-1 && s2[i]!=s2[now+1])now=kmp[now];
kmp[i]=now+1;
}//处理kmp数组
for(int i=1;i<=n;i++)
{
st[++len]=s1[i];//弹入栈
int now=dt[len-1];
while(now!=-1 && st[len]!=s2[now+1])now=kmp[now];
dt[len]=now+1;//记录
if(dt[len]==m)len-=m;//如果是可以匹配,弹出
}
for(int i=1;i<=len;i++)printf("%c",st[i]);//输出
printf("\n");
return 0;
}
kmp的优化
后来发现kmp可以进行优化。。。
其实放到后面也有一个原因,这个优化也会和一些应用冲突,建议建两个kmp数组,不过代码中我还是只建一个。
以例题为题目
先给出一张图
最后发现并没有匹配到一丁点东西QAQ,于是我们十分生气,总结了一些经验。
为什么跳了三次,都失败了?
人品差
共同点:
举个栗子(设母串为A,模式串为B,now为之前匹配到的长度):
你的
B
n
o
w
+
1
B_{now+1}
Bnow+1不等于
A
i
A_{i}
Ai,所以让
n
o
w
=
k
m
p
n
o
w
now=kmp_{now}
now=kmpnow,但是如果
B
n
o
w
+
1
=
B
k
m
p
n
o
w
+
1
B_{now+1}=B_{kmp_{now}+1}
Bnow+1=Bkmpnow+1,那么
B
k
m
p
n
o
w
≠
A
i
B_{kmp_{now}}\ne A_{i}
Bkmpnow̸=Ai。
大佬:是不是傻,为什么这样不去优化?
于是我们乖乖优化。
当 B n o w + 1 = B k m p n o w + 1 B_{now+1}=B_{kmp_{now}+1} Bnow+1=Bkmpnow+1,我们让 k m p n o w = k m p k m p n o w kmp_{now}=kmp_{kmp_{now}} kmpnow=kmpkmpnow岂不妙哉。
所以我们就可以让 B n o w + 1 ≠ B k m p n o w + 1 B_{now+1}\ne B_{kmp_{now}+1} Bnow+1̸=Bkmpnow+1
当然,这样子在匹配next数组时也是成立的,也就是可以在匹配时直接特判掉。
不过这样违背了原本kmp数组的定义,所以导致一些kmp的题目不能做了,这时候,我们可以把kmp数组的优化做成另一个数组储存就行了,主要看情况。
有些细节要注意(在例题中没有明显优化):
#include<cstdio>
#include<cstring>
#include<cstdlib>
using namespace std;
char s1[2100]/*母串*/,s2[2100]/*模式串*/;//字符串
int kmp[2100],ans,n,m;//kmp数组
int main()
{
while(1)
{
scanf("%s",s1+1);n=strlen(s1+1);
if(n==1 && s1[1]=='#')break;//判断
scanf("%s",s2+1);m=strlen(s2+1);//输入
kmp[0]=-1;ans=0;//一种让kmp[i]!=i的方法
int now;
for(int i=1;i<=m;i++)//子串
{
now=kmp[i-1]==-1?0:kmp[i-1];//因为有些是-1所以得特判
while(now>-1 && s2[i]!=s2[now+1])now=kmp[now];
now++;
if(s2[i+1]==s2[now+1])kmp[i]=kmp[now];//优化判断
else kmp[i]=now;
}
now=0;
for(int i=1;i<=n;i++)//母串匹配
{
while(now>-1 && s1[i]!=s2[now+1])now=kmp[now];
now++;
if(now==m)ans++,now=0;//统计答案
}
printf("%d\n",ans);
}
return 0;
}
题目大意:
字符串的结构是EAEBE组成的,A与B子串不固定,求E的最长长度。
题解:
设now=n,先不断跳
k
m
p
n
o
w
kmp_{now}
kmpnow,然后再for一遍(n-1)->1,跳他们的kmp,判断一下就行了,难度不是很难。但是当时没想到QAQ。
有一些小优化QWQ。
#include<cstdio>
#include<cstring>
#define N 1100000
using namespace std;
int kmp[N],n,ans=0;
char st[N];
bool rem[N],list[N];
inline int mymax(int x,int y){return x>y?x:y;}
int main()
{
int T;scanf("%d",&T);
while(T--)
{
scanf("%s",st+1);n=strlen(st+1);
kmp[0]=-1;
for(int i=1;i<=n;i++)
{
int now=kmp[i-1];
while(now>-1 && st[now+1]!=st[i])now=kmp[now];
kmp[i]=now+1;
}
//kmp数组处理
memset(rem,false,sizeof(rem));
memset(list,false,sizeof(list));
ans=0;//初始化
int root=kmp[n];
while(root>0)rem[root]=true,root=kmp[root];//先处理开头的E与结尾的E。
for(int i=n-1;i>=1;i--)
{
root=kmp[i];
while(root>0 && !list[root]/*优化,以前走过,现在不走*/ && root>ans/*更新不了,退出*/)
{
if(i<n-root+1)//判断区域不能重合
{
list[root]=true;
if(rem[root])//可以更新答案?
{
ans=mymax(ans,root);
break;//找到了,退出
}
}
root=kmp[root];//继续跳
}
}
printf("%d\n",ans);//输出
}
return 0;
}
扩展:
如果是求中间有k个E,求最小长度怎么办。(开头必须有个E,结尾不一定)。
我讲讲自己的看法,如果大家有更好的方法或觉得我的方法不好,可以在评论区跟我说一下。
Hash做法不说了。
讲讲KMP做法,还是从后往前找,跳kmp然后标记,不过因为末尾不一定是E,所以直接从n往1 for循环。
我们把rem定成结构体,分别记录 [ 1 , i ] [1,i] [1,i]的子串的出现次数与最后出现的子串的最后一个字符的位置,但次数到了 k − 1 k-1 k−1次记录(自己算一次),同时判断一下不要重叠,根据贪心,我们知道,当重叠的时候,后面的更优一点,没有出现,次数++,然后更新子串最后出现的子串的最后一个字符的位置。
大概这样,不知道对不对。。。
大家可以出这么一道毒瘤题卡卡别人QMQ
小结
KMP速度很快,最坏复杂度
O
(
n
+
m
)
O(n+m)
O(n+m),网上还有BM算法与Sunday算法,都说比KMP快,但是一查最坏是
O
(
n
∗
m
)
O(n*m)
O(n∗m),就没有去学,KMP的应用也很多,那些东西也不大必要去学懒,等到以后考Sunday算法再去学吧。
(:光速逃