[笔记]KMP算法 - 上（算法详解）

算法详解

KMP 是一种字符串匹配算法，可以在线性的时间复杂度内解决字符串的“模式定位”问题，即：

在字符串 $A$ 中查找字符串 $B$ 出现的所有位置。

我们称 $A$ 为主串，$B$ 为模式串。下文都用 $n$ 表示 $A$ 的长度，$m$ 表示 $B$ 的长度，下标从 $1$ 开始。

初始状态，我们用两个指针 $i,j$ 分别指向 $A$ 和 $B$ 的第 $1$ 位。

KMP 的主过程如下（后面会证明它的正确性）：

如果 $A[i]=B[j]$，则i++，j++。
如果 $A[i]\neq B[j]$：
- 如果 $j>1$，则j=nxt[j-1]+1。
- 如果 $j\le 1$，则i++。

其中，$nxt$ 数组是一个用于表示发生失配后，$j$ 回退到的位置。具体求法待会会说，下面我们用一个例子来理解 $nxt$ 的功能，我将 $nxt$ 数组画在图片的下方了。

初始状态。$i=1,j=1$。
$A[i]=B[j]$，同时右移 $i,j$。$i=2,j=2$。
$A[i]=B[j]$，同时右移 $i,j$。$i=3,j=3$。
$A[i]=B[j]$，同时右移 $i,j$。$i=4,j=4$。
$A[i]=B[j]$，同时右移 $i,j$。$i=5,j=5$。
$A[i]=B[j]$，同时右移 $i,j$。$i=6,j=6$。
发现 $A[i]\neq B[j]$，于是查表 $nxt[j-1]+1=nxt[5]+1=3$，于是 $j=3$。此时 $i=6$。

可以发现此时灰色箭头指向的两部分是相等的。

进一步来说，从上一张图开始，下划线的部分都是相等的。
OK我们继续，$A[i]=B[j]$，于是 $i,j$ 同时右移，$i=7,j=4$。
发现 $A[i]\neq B[j]$，查表得 $nxt[3]+1=2$，于是 $j=2$。此时 $i=7$。

我们又发现 $A$ 与 $B$ 的下划线部分重合了，所以仍然可以从重合部分之后开始比较。
然后 $A[i]=B[j]$……就一直比到结束了，就不放图了w。

似乎2.2的情况没有提到呢……其实就是如果第 $1$ 个字符就失配，就i++，这是很自然的。

我们可以把根据上面的过程（KMP 主过程）写出代码（下标从 $1$ 开始）：

i=1,j=1;

while(i<=n){

	if(a[i]==b[j]) i++,j++;

	else if(j>1) j=nxt[j-1]+1;

	else i++;

	if(j==m+1) cout<<i-j+1<<"\n";

	//输出配对的开始位置，理解一下这里

}

可以发现 $i$ 是始终不降的，比起暴力，KMP 通过避免 $i$ 指针的回滚操作，减少了时间开销。

到这里我们已经可以初步理解 $nxt$ 的含义，它是用来帮我们了解发生失配时，$j$ 应该回退到什么位置。

再进一步分析，我们发现：$nxt[x]$，其实就是 $B[1\sim x]$ 这一段的最长公共前后缀长度。

举个例子，YABAPQYABZABAAPYABAPQYABA。这是一个长度为 $25$ 的字符串，那么当它作为 $B$ 时：

$nxt[24]=9$，如你所见，红色部分是 $B[1\sim 24]$ 的公共前后缀，它的长度为 $9$。
$nxt[9]=3$，因为YAB是 $B[1\sim 9]$ 的公共前后缀，它的长度为 $3$。
$nxt[3]=0$，因为 $B[1\sim 3]$ 没有公共前后缀。
$nxt[25]=4$，因为YABA是 $B[1\sim 25]$ 的公共前后缀。

注意：公共前后缀可能有重叠部分，但是一个字符串不能作为它自己的公共前后缀（严格来说，我们把这种前/后缀称作真前/后缀，所以后面都带“真”来称呼了）。

公共真前后缀也可以称为border（不一定是最长），自然一个字符串可能有多个border。

我们规定，$nxt[x]$ 表示的必须是 $B[1\sim x]$ 这一段的最长公共真前后缀长度，这么定义是为了保证正确性，如果不规定最长，不能保证答案的正确性。后面的证明会提到。

现在我们的首要问题是，如何求 $nxt$ 数组？

我们假定 $i$ 之前的答案都已经求出，现在需要求 $nxt[i]$。

我们设 $j$ 为 $nxt[i-1]+1$，如下图：

最简单的情况自然就是 $B[i]=B[j]$，那么 $nxt[i]=j$，这是显然的。

但是也可能遇到更棘手的情况：

$B[i]\neq B[j]$，怎么办呢？

既然YABAPQYAB这个公共真前后缀不行，那就再找一个更小的！

显然更小的前后缀就是YAB了，怎么得来的呢？就是看 $nxt[j-1]$ 的值是多少，那么新的 $j$ 就是 $nxt[j-1]+1$。此时再看看 $B[i]=B[j]$ 是否成立。成立的话就 $nxt[i]=j$，不成立就继续找 $j$，直到找到 $B[i]=B[j]$，或者 $j=1$ 为止。

可以发现我们充分利用了之前计算出的$nxt$，将原规模逐步缩小，是不是有点归纳法的意味？

再来举一个不断更新 $j$ 直到 $j=1$ 为止的例子：

我们可以把这一步骤也写成代码（下标从 $1$ 开始）：

int i=2,j=1;//nxt[1]应为0，所以i从2开始

while(i<=m){

	if(b[i]==b[j]) nxt[i++]=j++;

	else if(j>1) j=nxt[j-1]+1;

	else nxt[i++]=0;

}

（是不是和上面的代码很像）

至此把两个代码拼接起来就能得到 KMP 的全过程了。

P3375 【模板】KMP

下标从 $1$ 开始

#include<bits/stdc++.h>

#define N 1000010

using namespace std;

string a,b;

int n,m,nxt[N];

int main(){

	cin>>a>>b;

	n=a.size(),m=b.size();

	a=' '+a,b=' '+b;

	int i=2,j=1;

	while(i<=m){

		if(b[i]==b[j]) nxt[i++]=j++;

		else if(j>1) j=nxt[j-1]+1;

		else nxt[i++]=0;

	}

	i=1,j=1;

	while(i<=n){

		if(a[i]==b[j]) i++,j++;

		else if(j>1) j=nxt[j-1]+1;

		else i++;

		if(j==m+1) cout<<i-j+1<<"\n";

	}

	for(int i=1;i<=m;i++) cout<<nxt[i]<<" ";

	return 0;

}

下标从 $0$ 开始

#include<bits/stdc++.h>

#define N 1000010

using namespace std;

string a,b;

int n,m,nxt[N];

int main(){

	cin>>a>>b;

	n=a.size(),m=b.size();

	int i=1,j=0;

	while(i<m){

		if(b[j]==b[i]) nxt[i++]=++j;

		else if(j) j=nxt[j-1];

		else nxt[i++]=0;

	}

	i=0,j=0;

	while(i<n){

		if(a[i]==b[j]) i++,j++;

		else if(j) j=nxt[j-1];

		else i++;

		if(j==m) cout<<i-j+1<<"\n";

	}

	for(int i=0;i<m;i++) cout<<nxt[i]<<" ";

	return 0;

}

正确性证明

我们刚接触 $nxt$ 的定义时，可能会有疑问：为什么 $nxt$ 一定要表示 $B[1\sim x]$ 这一段的最长公共真前后缀长度？

我们证明一下 KMP 的正确性，顺带解决这个问题。

根据 KMP 的流程，如果遇到失配的情况，我们先找 $B[1\sim (j-1)]$ 中的最长公共真前后缀（如图，用 $f$ 表示）的长度 $nxt[j-1]$，然后把 $j$ 置为 $nxt[j-1]+1$，如下图。

要证明 KMP 是正确的，首先需要证明 $j$ 回退时不会跳过正确答案。

我们假设在 $j>nxt[j-1]+1$ 时存在匹配，如下图，那么灰色箭头连接的部分都相等。

自然，黄色大括号部分（不包含 $i,j$）也相等，那么黄色部分的长度 $=j-1$。

回到第 $1$ 张图（$j'$ 表示第 $1$ 张图情况下的 $j$），根据假设，$j>|f|+1$，即黄色部分长度 $>|f|$。

这样的话，黄色部分就成了 $B[1\sim j']$ 最长的公共真前后缀，与“$f$ 是 $B[1\sim j']$ 最长公共真前后缀”矛盾。

得到的结论是：$j>nxt[j-1]+1$ 时一定不存在匹配。

这样我们的问题就迎刃而解了：如果 $nxt$ 不是最长，上面的情况就可能不形成矛盾，进而 $j>nxt[j-1]+1$ 时也可能存在解，而这被我们忽略掉了，所以正确性不能保证。

但正确性证明还没完，我们还需要考虑 $j<nxt[j-1]+1$ 的情况。

事实上，这种情况是可能存在答案的，但我们可以证明，如果每次失配 $j$ 都回退到 $nxt[j-1]+1$，一定可以把这种情况的答案找出来。

还是图 $1$ 的初始状态，现在 $A[i]\neq B[j]$，发生失配。我们现在让 $j<nxt[j-1]+1$：

也就是 $j$ 现在在 $f$ 里面了。现在我们的问题是：如果这种情况下存在答案，我们按 $j=nxt[j-1]+1$ 的步骤，是否能找出这个答案？

我们假设在 $j<nxt[j-1]+1$ 中存在答案，如上图黄色线段所示。

现在我们让 $j=nxt[j-1]+1$：

我们继续匹配，那么这一轮的失配位置一定 $j\in [nxt[j−1]+1,m+1]$（$j=m+1$ 就是匹配成功）。

如下图，虚线位置即失配位置。

如上图，如果绿色线段就是 $B[1\sim (j-1)]$ 的最长公共真前后缀，那么下一轮应该将两个绿色线段对齐继续匹配，这样黄色线段这个答案就被找到了。

如果不是呢？

如上图，假设粉色部分是真正的公共前后缀，那么我们接下来应该把 $j$ 回退到粉色的下一个位置：

此时两个粉色重合。我们可以发现，这和上上张图的情形类似，只不过两个绿色离得更近了。这样重复上面的过程，再找第 $1$ 个失配位置，不断逼近，总有一次绿色部分会成为 $B[1\sim (j-1)]$ 的最长公共真前后缀。至此，我们证明了如果 $j<nxt[j-1]+1$ 存在答案，按我们的方法一定能找到它。

综上，KMP 的正确性得证。

复杂度证明

通过看代码能发现两部分实现相似，所以就一块说了：

$i$ 每增加 $1$，$j$ 最多也增加 $1$，从而 $j$ 最多增加 $len$ 次，进而最多减少 $len$ 次。

所以处理 $nxt$ 是 $O(m)$ 的，主过程是 $O(n)$ 的，总时间复杂度就是 $O(n+m)$ 了。

——字符串学习笔记 · 浅析KMP——单模式串匹配算法 - 皎月半洒花

细节

术语

我们前面提到的 $nxt$ 数组，其实叫做PM表（Partial Match Table，部分匹配表）。

真正意义上的 $next$ 数组，就是把PM表整体右移一位，最后一个值舍弃掉，然后在第 $1$ 位补 $-1$。这个似乎并不常用，因为最后一个值舍弃掉了，所以只能匹配一次。

代码实现

KMP的代码，网上有很多种写法，有和上面放的代码一样的while类型写法。

当然你也可以变一下，用for循环套while，效果是一样的。具体用哪个看你的选择。

下标从 $1$ 开始

#include<bits/stdc++.h>

#define N 1000010

using namespace std;

string a,b;

int n,m,nxt[N];

int main(){

	cin>>a>>b;

	n=a.size(),m=b.size();

	a=' '+a,b=' '+b;

	for(int i=2,j=1;i<=m;i++){

		while(b[i]!=b[j]&&j>1) j=nxt[j-1]+1;

		if(b[i]==b[j]) nxt[i]=j++;

	}

	for(int i=1,j=1;i<=n;i++){

		while(a[i]!=b[j]&&j>1) j=nxt[j-1]+1;

		if(a[i]==b[j]){

			if(j==m) cout<<i-j+1<<"\n";

			j++;

		}

	}

	for(int i=1;i<=m;i++) cout<<nxt[i]<<" ";

	return 0;

}

下标从 $0$ 开始

#include<bits/stdc++.h>

#define N 1000010

using namespace std;

string a,b;

int n,m,nxt[N];

int main(){

	cin>>a>>b;

	n=a.size(),m=b.size();

	for(int i=1,j=0;i<m;i++){

		while(b[i]!=b[j]&&j) j=nxt[j-1];

		if(b[i]==b[j]) nxt[i]=++j;

	}

	for(int i=0,j=0;i<n;i++){

		while(a[i]!=b[j]&&j) j=nxt[j-1];

		if(a[i]==b[j]){

			if(j==m-1) cout<<i-j+1<<"\n";

			j++;

		}

	}

	for(int i=0;i<m;i++) cout<<nxt[i]<<" ";

	return 0;

}

还有很多写法是把上面代码的 $j$ 整体 $-1$ 来使用，本质上是一样的，不过代码实现需要先j++才能得到与$i$匹配的位置。就不放代码了。

不同写法原理都是一样的，不要拘泥于细节，根据自己的习惯使用即可。

$\mathcal{NEXT\ \ \ PHANTASM...}$