kmp学习笔记

最新推荐文章于 2022-12-07 10:45:18 发布

zhangjianjunab

最新推荐文章于 2022-12-07 10:45:18 发布

阅读量175

点赞数

本文链接：https://blog.csdn.net/zhangjianjunab/article/details/83893544

版权

没错，博主又开始学算法了。。。~~话说我以前不是叫自己猴子吗？~~

还是那句话，因为是个人的感受与体验，所以写上原创。

kmp简介

模版题

平常我们字符串匹配，暴力 $O (n m)$ 是不是感觉自己已经可以称霸全世界了？

不是！~~还有STL~~

STL的大佬就不要看我这种蒟蒻的博客了。

当然，时间慢自然会有大佬去开发一种算法来加速。
在这里插入图片描述

就是他们，研究出了kmp ~~看毛片~~算法。
sto,sto,sto

注：作者字符串均从下标为1开始

kmp的过程

kmp的思想是什么?

建一个kmp数组， $kmp_{i}$ 代表在一个字符串中 $i-kmp_{i}+1,i]$ 与 $1,kmp_{i}]$ 是匹配的。（注意， $kmp_{i}\ne i$ ）。

在这里插入图片描述

那么，当我们知道了 $kmp_{i}$ 如何求出 $kmp_{i+1}$ ？
（设字符串为 $s s$ 数组）

如果 $ss[kmp_{i}+1]=ss[i+1]$ 那么 $kmp_{i+1}=kmp_{i}+1$ ，这一步很简单。
如果 $ss[kmp_{i}+1]\ne ss[i+1]$ ，那怎么办？ $kmp_{i+1}=0$ ，然后重新循环一遍匹配？
不不不，想想kmp数组的定义，一个字符串中 $i-kmp_{i}+1,i]$ 与 $1,kmp_{i}]$ 是匹配的，我们不能让这一个重要的资源浪费了。

匹配过程：

在这里插入图片描述

最后我们就匹配成功了。

所以，当 $ss[kmp_{i}+1]\ne ss[i+1]$ 时，我们可以设 $now=kmp_{i}$
然后不断匹配，匹配不成功就让 $now=kmp_{now}$ ，我们可以设 $kmp_{0}=-1$ 当 $ss[kmp_{i}+1]=ss[i+1]$ 或 $n o w = - 1$ 时退出，同时用 $kmp_{i+1}=now+1$ 。
其实第一个也可以这么做，因为当 $now=kmp_{i}$ 时就已经退出了，所以 $kmp_{i+1}=now+1=kmp_{i}+1$ 。

我们可以先处理出子串的kmp数组，那么怎么做？
设 $i$ 为当前已经匹配到的母串的位置，那么设now代表母串中 $[i - n o w + 1, n o w]$ 与子串的 $[1, n o w]$ 完全匹配，那么的话，就像建立kmp数组那样，以母串的第 $i$ 个位置now来处理出 $i + 1$ 的位置的now。

至于具体过程，跟处理kmp数组那样，换汤不换药，自己想。

~~就是你懒！~~

而这里，就是判断当 $n o w =$ 子串的长度时， $a n s + +, n o w = 0$ 。

注：这里的kmp数组许多人都失败 $(f a i l)$ 数组。
注意，不能让 $kmp_{i}=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\bmod (n-kmp_{n})==0$ ，那么 $n-kmp_{n}$ 就是循环节，否则不存在循环节。

Why?

首先，如果 $kmp_{n}<(n+1)/2$ 那么 $n\bmod (n-kmp_{n})\ne 0$
因此我们不讨论这种情况。

如图：
注：这里a1-a10代表字符串的前缀，b1-b10是字符串的后缀

在这里插入图片描述

那我们现在需要证明当 $n\bmod (n-kmp_{n})\ne 0$ 时没有循环节。
反证法：
如果有，设循环节长度为 $k$ ，然后设 $kmp_{n}\%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-kmp_{n}$ ？
答案是肯定的，假设从结尾求得循环节是 $a_{1}a_{2}a_{3}...a_{k}$ 而字符串则是 $a_{i}a_{i+1}...a_{k}a_{1}a_{2}...a_{k}...$ 。那么 $kmp_{n}$ 除了像上次那样统计了循环节外，还统计了开头 $a_{i}a_{i+1}...a_{k}$ 的部分，所以拿 $n-kmp_{n}$ 刚好就是循环节的长度，而且因为题意，我们不用担心无解的情况，直接输出就好了。

#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;
}

题意看不懂QAQ。。。

将题意转成人话：
求字符串A的所有前缀AA，定义最长的不断复制自己再接到后面能够覆盖前缀AA且不等于AA的字符串为AA的周期（周期可以是空串），如abababab，ababab通过不断复制自己再接到后面形成abababababab…能够覆盖abababab，且ababab的长度是最长的，求所有前缀AA的周期长度总和。

这道题，就是要我们求出每个前缀的最长循环节，跟上题差不多，不过找的方式变了。

从前往后找与从后往前找的最长循环节长度一样。

那么我们考虑题意是接到不断复制接到前面，那么我们可以知道

在这里插入图片描述

而且通过上一道题，我们可以知道，这里的红色块就是上一道题的循环节，而循环节就是 $now-kmp_{now}$ ，我们就可以不断用 $now\%(now-kmp_{now})$ 来处理出黄色块的长度，然后用前缀AA的长度减去黄色块的长度，就是最长循环节的长度了。

当然也有细节：

当 $kmp_{now}=0$ 时退出。
在模的过程，别忘了当now=0时，now= $now-kmp_{now})$ 。（特判没有黄色块的情况。）

优化：当 $kmp_{i}\ne 0$ 时，我们可以用 $kmp_{i}=前缀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;
}

当然，有的大佬为了让过程简洁，用另一种方法，思想一样，方法不同。

每次跳 $kmp_{now}$ ，当 $kmp_{now}=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})$ 可以过！

不过如何判断一个区间是否符合？

设 $now=kmp_{r}$ ，然后判断l->now的长度符不符合要求，不符合继续让 $now=kmp_{now}$ ，符合，统计答案，退出。

可能说的不好。。。看代码然后自行理解。

#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_{now+1}$ 不等于 $A_{i}$ ，所以让 $now=kmp_{now}$ ，但是如果 $B_{now+1}=B_{kmp_{now}+1}$ ，那么 $B_{kmp_{now}}\ne A_{i}$ 。

大佬：是不是傻，为什么这样不去优化？
于是我们乖乖优化。

当 $B_{now+1}=B_{kmp_{now}+1}$ ，我们让 $kmp_{now}=kmp_{kmp_{now}}$ 岂不妙哉。

所以我们就可以让 $B_{now+1}\ne B_{kmp_{now}+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，先不断跳 $kmp_{now}$ ，然后再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]$ 的子串的出现次数与最后出现的子串的最后一个字符的位置，但次数到了 $k - 1$ 次记录（自己算一次），同时判断一下不要重叠，根据贪心，我们知道，当重叠的时候，后面的更优一点，没有出现，次数++，然后更新子串最后出现的子串的最后一个字符的位置。

大概这样，不知道对不对。。。
~~大家可以出这么一道毒瘤题卡卡别人QMQ~~

小结

KMP速度很快，最坏复杂度 $O (n + m)$ ，网上还有BM算法与Sunday算法，都说比KMP快，但是一查最坏是 $O (n * m)$ ，就没有去学，KMP的应用也很多，那些东西也不大必要去学懒，等到以后考Sunday算法再去学吧。

(:光速逃

zhangjianjunab

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
kmp学习笔记

没错，博主又开始学算法了。。。话说我以前不是叫自己猴子吗？还是那句话，因为是个人的感受与体验，所以写上原创。模版题kmp简介平常我们字符串匹配，暴力O(nm)O(nm)O(nm)是不是感觉自己已经可以称霸全世界了？不是！还有STLSTL的大佬就不要看我这种蒟蒻的博客了。当然，时间慢自然会有大佬去开发一种算法来加速。就是他们，研究出了kmp看毛片算法。sto,sto,stokm...
复制链接

扫一扫