算法学习笔记：KMP 算法

Plozia

于 2021-01-22 21:47:41 发布

阅读量478

点赞数

分类专栏：字符串学习笔记 + 专项训练

本文链接：https://blog.csdn.net/BWzhuzehao/article/details/112982365

版权

学习笔记 + 专项训练同时被 2 个专栏收录

77 篇文章 2 订阅

订阅专栏

字符串

4 篇文章 0 订阅

订阅专栏

本文深入探讨了KMP算法在字符串匹配问题中的应用，通过自匹配操作求解Next数组，减少不必要的匹配次数，从而提高效率。文章详细介绍了KMP算法的原理、字符串匹配过程及时间复杂度分析，并提供了相应的代码实现。KMP算法通过利用前后缀关系避免了暴力匹配的重复计算，降低了时间复杂度。

摘要由CSDN通过智能技术生成

1.概述

KMP 算法是一种字符串算法，具体解决的问题为字符串匹配问题：

给出一个模式串 $t$ ，文本串 $s$ ，请问 $t$ 是否为 $s$ 的字串 / $t$ 在 $s$ 中出现了几次等等问题。

后文中无特殊说明， $n$ 为文本串 $s$ 的长度， $m$ 为模式串 $t$ 的长度。

2.例题

link

我们要求两个东西：

模式串 $t$ 在文本串 $s$ 中出现的位置。
模式串 $t$ 的 $b o r d e r$ 长度。

我们暂且先不管这个 $b o r d e r$ ，考虑第 1 个问题。

显然有一种暴力匹配的方法：直接从最前面的位置开始，在文本串 $s$ 中截出长度为 $m$ 的字串， $O (m)$ 暴力匹配。

然而，这样做会发现最坏理论复杂度到了 $O (n m)$ ！我们不能忍受。

于是 KMP 就出现了。

比如面对这样的两个字符串：

文本串 s = a a a b a c a b a c d
模式串 t =   a b a

规定起始点为 $i$ 。

如上所示，假设我们现在匹配到了 $i = 2$ 的位置。我们发现不匹配（失配），那么如果是暴力做法，那么在 $i = 3$ 的位置就会重新匹配一次。

但是我们完全可以不用这么做，因为 模式串 $t$ 的前面两个字符跟文本串 $s$ 的前面两个字符相同，可以直接从第 3 位开始匹配。

而 KMP 的任务就是尽可能多的实现上面这句话。

那么我们又怎么判断要跳到哪里呢？

还记得 $b o r d e r$ 吗？ $b o r d e r$ 可以帮助我们判断要跳到哪里。

比如说我们现在在文本串第 $i$ 个位置开始匹配，结果失配了，假设失配位置为 $j$ ，那么我们直接从 $border_j$ 开始匹配。

下文记 $Next_i$ 为 $border_i$ 。

想想为什么？ $b o r d e r$ 的定义是：在一个字符串 $s$ 中，如果一个串 $s t r$ 满足其既是 $s$ 的前缀，又是 $s$ 的后缀，那么 $s t r$ 就是 $s$ 的一个 $b o r d e r$ ，而一个串的 $b o r d e r$ 指他的所有 $b o r d e r$ 的最长长度。

那么如果模式串 $t$ 失配，我们可以跳到 $Next_t$ 这个位置继续匹配，而不需要直接从头匹配。

那么如何求 $N e x t$ 数组呢？

2.1 自匹配操作

求 $N e x t$ 数组在 KMP 中称为自匹配操作。

比如对于模式串 $\text{t = a b a b a c a b a}$ ，我们要对其进行自匹配操作。

注意： $Next_i=i$ 是没有意义的！

首先显然的， $Next_1=0$ 。

那么 $Next_2$ 呢？还是等于 0。

$Next_3$ ？等于 1。

但是我们是怎么知道 $Next_3$ 等于 1 的呢？上图！

在这里插入图片描述

比如我们要求 $Next_i$ ，而此时我们已经保证 $Next_{1...i-1}$ 已经求好。

上图中红色部分表示这个串的 $b o r d e r$ 。

设 $Next_{i-1}=j$ ，那么我们假设 $j$ 在这个位置：

在这里插入图片描述

由于上图中两个蓝色部分完全相同，那么我们首先判断一下 $t_{j +1}$ 跟 $t_i$ 是否相同，如果相同 $Next_i$ 就求出来了。

但是不相同呢？或许有的人会说了：那不是还要暴力查找吗？

不需要！因为 $Next_{i-1}=j$ ，此时如果我们再取 $k=Next_j$ （为了方便擦去了红色部分）：

在这里插入图片描述

~~图很丑（确信~~

那么首先在 $[1, j]$ 内两段绿色字符串相等，而由于 $Next_{i-1}=j$ ，根据传递性， $[1, k]$ 就会跟 $[i - k, i - 1]$ （也就是最后这段绿色的）相同，此时我们只需要判断 $t_{k+1}$ 是否等于 $t_i$ 就可以了。相同就结束，不相同？继续这么做呗！

所以我们会发现，实质上 KMP 充分利用了 $b o r d e r$ 的性质，以 $N e x t$ 数组为媒介，减少了转移次数，从而降低时间复杂度。

不过需要注意：当 $j$ 跳到 0 时，如果 $t_1 \ne t_i$ ，此时 $Next_i = 0$ ；否则其余所有情况， $Next_i = j + 1$ 。

那么在 $\text{t = a b a b a c a b a}$ 中， $Next_3=1$ 也就不难想了吧！

对于这个文本串 $t$ ， $Next=\{0,0,1,2,3,0,1,2,3\}$ 。

于是自匹配操作漂亮解决。

代码：

int j = 0;//初始化为 0
for (int i = 2; i <= m; ++i)
{
	while (j && s2[j + 1] != s2[i]) j = Next[j];//不断往前找
	if (s2[j + 1] == s2[i]) ++j;//注意 +1
	Next[i] = j;
}

其实此时你会发现，题目要求的 $b o r d e r$ 长度就是我们的 $N e x t$ 数组。

这里说句闲话：在几年之前 luogu 的模板题是说：

直接输出 $N e x t$ 数组。
如果你不知道什么是 $N e x t$ 数组，自行学习 KMP 算法。

不过或许是因为一些原因（比如并不是所有人的 KMP 都用的是 $N e x t$ 的，也有人用 $f a i l$ 命名），最后变成了输出 $b o r d e r$ 长度。

2.2 字符串的匹配

那么回到我们的问题：求模式串 $t$ 在文本串 $s$ 内分别出现在哪几个位置。

现在有了 $N e x t$ 数组，再加上我们前面说的，应该不难想了。

首先我们先初始化 $j = 0$ ，然后开始暴力匹配。

当我们发现 $t_{j+1}=s_i$ 时，匹配成功， $j$ 右移。

否则， $t$ 和 $s$ 失配，此时根据我们最开始所说的，我们将 $j$ 重置为 $Next_j$ 继续匹配。

当完全匹配到一个字符串时，我们输出位置 并且重置 $j=Next_j$ 。（这点非常重要！否则在下一个位置匹配的时候 $j$ 会被重置为一些奇奇怪怪的东西，导致操作失误，想知道的读者可以自己尝试）

那么这就是 KMP 的字符串匹配过程。

代码：

j = 0;
for (int i = 1; i <= n; ++i)
{
	while (j && s2[j + 1] != s1[i]) j = Next[j];//不相同就跳
	if (s2[j + 1] == s1[i]) ++j;//注意 +1
	if (j == m) {printf("%d\n", i - m + 1); j = Next[j];}//一定要重置！
}

2.3 时间复杂度分析

KMP 的时间复杂度有一点迷。

在随机数据下：

对于每一个 $i$ 位置，我们在匹配字符串时（包括自匹配）正常情况下 $j + +$ 只会执行一次，那么 $i$ 从 1 到 $n$ ， $j$ 从 1 到 $m$ ，互不干扰，时间复杂度为 $O (n + m)$ 。

但是很遗憾的是据说 KMP 比较容易被卡成 $O (n m)$ 的时间复杂度，不过作者目前还没有找到 hack 数据。

~~还是 hash 好，稳定的 O(n) 算法~~

2.4 代码

~~话说上面都放出来了还有必要再放一遍吗~~

代码：

#include <bits/stdc++.h>
using namespace std;

typedef long long LL;
const int MAXN = 1e6 + 10;
int n, m, Next[MAXN];
char s1[MAXN], s2[MAXN];

int read()
{
	int sum = 0, fh = 1; char ch = getchar();
	while (ch < '0' || ch > '9') {if (ch == '-') fh = -1; ch = getchar();}
	while (ch >= '0' && ch <= '9') {sum = (sum << 3) + (sum << 1) + (ch ^ 48); ch = getchar();}
	return sum * fh;
}

int main()
{
	scanf("%s", s1 + 1);
	scanf("%s", s2 + 1);
	n = strlen(s1 + 1); m = strlen(s2 + 1);
	int j = 0;//初始化为 0
	for (int i = 2; i <= m; ++i)
	{
		while (j && s2[j + 1] != s2[i]) j = Next[j];//不断往前找
		if (s2[j + 1] == s2[i]) ++j;//注意 +1
		Next[i] = j;
	}
	j = 0;
	for (int i = 1; i <= n; ++i)
	{
		while (j && s2[j + 1] != s1[i]) j = Next[j];//不相同就跳
		if (s2[j + 1] == s1[i]) ++j;//注意 +1
		if (j == m) {printf("%d\n", i - m + 1); j = Next[j];}//一定要重置！
	}
	for (int i = 1; i <= m; ++i) printf("%d ", Next[i]);
	printf("\n"); return 0;
}