kmp字符串匹配 | 易学教程

文章目录

1. what is kmp?
2.暴力算法

2.1 暴力中的暴力
2.2 暴力中的优化

3.kmp算法

3.1 数组定义
3.2 关于kmp难以理解的原因简要分析
3.3 next数组的预处理
3.4 next数组的应用

4. kmp时间复杂度证明
5.模板题代码
6.写在最后

1. what is kmp?

$kmp$ 是一种字符串匹配算法，用于在 $s$ 串中找到所有连续子串 $t$

由K什么，M什么，P什么三个人提出，所以叫 $kmp$

2.暴力算法

2.1 暴力中的暴力

如果是暴力的做法，我们会怎么做？
就直接拿 $s$ 的每一位当开头，然后往后走，就像这样

比如说我们现在我们要在 $abcabaababaa$ 串中找 $abab$

那么暴力的做法显然就是这个样子的

在这里插入图片描述

但是这样肯定会很慢，复杂度 $O(|s|\cdot |t|)$
但是他慢在哪里了呢？

比如说在第四步的时候，我们发现a和c不匹配，但是我们接下来还是一步一步的跳到了第七步，但是因为第一个字符是a，很明显他不可能和b或者c匹配，所以我们可以直接跳到下一个开头的地方，而不用经过b，或者c

2.2 暴力中的优化

所以我们顺着上面的想法，我们想到先在 $s$ 子串中找到 $t$ 的第一个字符所在的位置，每次直接跳到下一个

这样的话…至少上面那个能快一半
但是如果遇到一个
$s=aaaaaaaaaa\cdot\cdot\cdot aaaaaaaabc,t=abc$
就炸了

那么我们可以顺着这个思路去想

3.kmp算法

3.1 数组定义

next数组
在 $kmp$ 算法中，我们要设立一个数组 $nxt[i]$ 表示 $t$ 前 $i$ 个字符组成的字符串中相同前缀后缀的长度（C++编译器中 $next$ 是关键字）

我们举个栗子

现在有一个子串是aababaaba，那么a和aaba都是他的相同前缀后缀，最长的就是aaba就是4

为什么要这样存呢？比如我们发现我们匹配到了最后一个a发现他是没有匹配上的，我们不需要把 $t$ 子串跳到开头，我们可以直接从第4位的a开始匹配，这样就节省了不少的时间

s,t字符串
在本文中，所有的字符串都是从1开始储存的，这样不会出现我们跳到负数的情况，减少了特判

其中我们要在 $s$ 串中查找 $t$ 串

设 $ls=|s|,lt=|t|$

3.2 关于kmp难以理解的原因简要分析

$kmp$ 算是一种不太好理解的算法，原因我觉得主要有这样几种

各个文章的字符串储存方式都不大相同，有从0开始的，也有从1开始的
各个文章的的代码写法也有不少区别
$kmp$ 的思想其实很简单，但是表达出来并不容易（呼之欲出的感觉），加上代码的边界特判问题也不易讲清

3.3 next数组的预处理

那么我们说了， $next$ 数组是用来表示 $t$ 串中最长相同前缀后缀的长度的，所以我们需要在 $t$ 串中去自己匹配自己

先放下代码：

	for(int i=2,j=0;i<=lt;i++){
		while(j&&t[j+1]!=t[i])j=nxt[j];
		if(t[j+1]==t[i])j++;
		nxt[i]=j;
	}

这种写法是我认为比较好的一种写法，因为他不需要在同一个循环里来回跳 $i,j$ 我们每次循环里就把 $i$ 匹配好了就好了

整个算法的流程大概是这个样子的

显然，next[1]=0
对于处理next[i] (i>1)的情况时，如果我们发现当前的j+1（因为j最开始表示的是上一位的next值）和i不匹配，那么我们就一直往前跳直到跳到头或者匹配成功
如果匹配成功，那么next[i]=j+1（因为这两位相等，相同前缀后缀长度就是j+1）,反之为0

那么这样我们就完成了对next数组的预处理
（当然如果你这里没有看懂可以往下看，有动图助于大家理解）

3.4 next数组的应用

我们现在已经知道了next数组，那么我们接下来应该怎么求解呢？

先上代码：

	for(int i=1,j=0;i<=ls;i++){
		while(j&&t[j+1]!=s[i])j=nxt[j];
		if(t[j+1]==s[i])j++;
		if(j==lt){printf("%d\n",i-lt+1),j=nxt[j];}	
	}

其实我们发现和上一个几乎是一模一样的，具体思路也差不多

给组动图吧
在这里插入图片描述
这是第一次我们在第一个位置匹配

此时我们发现 $s$ 和 $t$ 在第六位不匹配，我们看next[6]=2，我们就可以把 $t$ 串的第二位和 $s$ 的第六位进行匹配
在这里插入图片描述
然后 $continue$

我们看到 $s$ 串的第14位和 $t$ 串的第11位不匹配，我们看next[11]=5
我们就拿 $t$ 串的第五位和 $s$ 串的第14位继续匹配

后面也差不多就是这样了，大家可以自己手推一下

来个完整版的：
在这里插入图片描述

4. kmp时间复杂度证明

可以证明， $kmp$ 的时间复杂度是 $O(|s|+|t|)$ ，或者说 $O(|s|)$ ,因为 $|t|\leq |s|$

下面简单的说一下

我们发现 $kmp$ 整个函数执行过程中，一共只有两个操作

j++，即匹配成功， $O(1)$
j=next[j]，匹配失败， $O(?)$

但是我们发现，虽然2不可求，但是经过这样的匹配之后，j的值一定是在减少的，但是j不能减成负的，所以操作2最多做的次数和操作1一样多，那么这时候复杂度是 $2*len$

因为在 $kmp$ 过程中，需要 $t$ 和 $t$ 匹配一次， $s$ 和 $t$ 匹配一次，所以在最坏情况下，复杂度等于 $O(2|s|+2|t|)=O(|s|+|t|)=O(|s|)$

5.模板题代码

# include <cstdio>
# include <algorithm>
# include <cstring>
# include <cmath>
# include <climits>
# include <iostream>
# include <string>
# include <queue>
# include <stack>
# include <vector>
# include <set>
# include <map>
# include <cstdlib>
# include <ctime>
using namespace std;

# define Rep(i,a,b) for(int i=a;i<=b;i++)
# define _Rep(i,a,b) for(int i=a;i>=b;i--)
# define RepG(i,u) for(int i=head[u];~i;i=e[i].next)

typedef long long ll;
const int N=1e6+5;
const int inf=0x7fffffff;
const double eps=1e-7;
template <typename T> void read(T &x){
	x=0;int f=1;
	char c=getchar();
	for(;!isdigit(c);c=getchar())if(c=='-')f=-1;
	for(;isdigit(c);c=getchar())x=(x<<1)+(x<<3)+c-'0';
	x*=f;
}

char s[N],t[N];
int ls,lt;
int nxt[N];

void kmp(){
	for(int i=2,j=0;i<=lt;i++){//t,t匹配
		while(j&&t[j+1]!=t[i])j=nxt[j];
		if(t[j+1]==t[i])j++;
		nxt[i]=j;
	}
	for(int i=1,j=0;i<=ls;i++){//s,t匹配（当然你也可以把这两个匹配写成一个函数调用两次）
		while(j&&t[j+1]!=s[i])j=nxt[j];
		if(t[j+1]==s[i])j++;
		if(j==lt){printf("%d\n",i-lt+1),j=nxt[j];}	
	}
}

int main()
{
	scanf("%s%s",s+1,t+1);
	ls=strlen(s+1),lt=strlen(t+1);
	kmp();
	Rep(i,1,lt)printf("%d ",nxt[i]);
	puts("");
	return 0;
}

6.写在最后

这篇文章参考自
https://blog.csdn.net/f1033774377/article/details/82556438（动图来源）
https://blog.csdn.net/hqw11/article/details/97504974（时间复杂度分析）

感谢 $akioi$ 的gjm2005，他让这篇文章没有鸽

来源：CSDN

作者：devout_

链接：https://blog.csdn.net/devout_/article/details/104167030

标签

kmp