浅析KMP算法

浅析KMP算法

前言和导引

今天数据结构课学了字符串的相关内容，其中着重介绍了KMP算法。

KMP是一种非常好用的字符串匹配算法。对于给定的长度为$m$的字符串$s(String)$，和需要匹配的长度为$n$的模式串$p(Pattern)$，KMP能够实现$O(m+n)$时间复杂度级别的匹配。相比于传统的$O(m\ast n)$的暴力匹配，是非常大的提升。

高中学竞赛的时候只是接触过KMP，而且第一次看没有什么深刻的理解，更多的只是背一下模板，考试的时候能用上。现在回过头来再次思考KMP算法的实现过程，会发现这个算法思路是非常简单清晰的的。同样，算法的代码也很短。

个人感觉，KMP算法的产生是很自然的。当我们发现暴力匹配会损失掉一些字符串信息的时候，当我们发现暴力匹配做了很多次不必要的检测的时候，KMP算法的思路就出来了：那些已经匹配成功的字符能不能派上用场呢？

算法剖析

要理解KMP算法的重点，我们先回顾一下暴力匹配的过程。假设在字符串$s$的位置$i$，字符串$p$的位置$j$，发生了字符失配(匹配不成功)，那么$i$会跳转到原来$p[1]$对应的位置，$j$则会变成初始位置$0$，以便继续下一次的匹配。注意到，字符串$p$仅仅滑动了一格。

例如，我们有：

$s:abaabaabcabaabc$
$p:abaabc$

第一次匹配直到$p$的最后一位$p[5]==c$才会停止。这之后，$p$向后滑动了一格，变成：

$abaabaabcabaabc$
$abaabc$

但是，如果细心一些，你会发现，$p$完全可以再往后多移动一些，成为：

$abaabaabcabaabc$
$abaabc$

这样做移动，不仅$p$滑动的距离长了，而且我们不用再从$p$的开头开始匹配。

以上是我们用肉眼观察到的现象。对此，我们不禁要问：为什么可以这么做？要怎样才能把这种机制程序化表达出来？

让我们回到失配的字符，$p[5]==c$上。稍加观察就会发现，$p[5]$前面的两个字符和$p$开头的两个字符按从左到右的顺序看起来一样，都是$ab$。于是，我们便把$p$直接拉过来，让$p[2]$移动到原来$p[5]$的位置。这样，$p[0],p[1]$就和原来的$p[3],p[4]$对齐了，而且我们的匹配也从$p[2]$开始，而不是从$p[0]$重新匹配。

到这里，我们已经发现了KMP的小秘密：利用一定长度的前缀和后缀相同的特点，拉长模式串移动的距离，并且减少冗余匹配的次数。具体来说，模式串$p$移动的距离变成了$j-l$，并且会从$p[l]$开始匹配。其中$l$是失配字符前面的字符串中，前缀和后缀能相等的最长长度。例如，对于$p[5]$来说，$l==2$。

你可能还会问：中间略过去的那些字符怎么办？难道没有可能匹配成功的吗？要回答这个问题，让我们回头再看：

$p:abaabc$

$p[5]$前面的字符串$abaab$，其前缀和后缀最长的能相等的长度就是$2$。对于长度为$3$和$4$的前缀后缀，它们是不相等的。如果你让模式串移动比$j-l$更少的距离，也就是说，考虑了那些本该被略过的字符，那么你会发现，他们一定是不能匹配成功的。因为比$2$更长的前缀和后缀注定无法相等，而此时的后缀与字符串$s$中的对应字符串相等，从而前缀就不可能与$s$中的对应字符串相等了。

所以，我们要想加快字符串的匹配，重点就是找出$p$的每个字符$p[i]$前面的字符串$p[0toi-1]$中，前缀和后缀能相等的最长长度。在KMP中，这些数据用一个叫做$next$的数组存储。$next[i]$就表示位置$i$前面的字符串$p[0toi-1]$中，前缀和后缀能相等的最长长度。

具体实现——next数组

要求$next$数组，我们假设位置$i$前面的$next$都已经求出，然后考虑$next[i]$怎么求。

因为$next[i-1]$已经求好，我们记$k=next[i-1]$。这就意味着，$p[0]$到$p[k-1]$与$p[i-k-1]$到$p[i-2]$对应相等。如果双方后面再接上一个相等的字符，也就是$p[k]==p[i-1]$，那么$next[i]$的值就可以直接知道了，等于$next[i-1]+1$。

上面是简单的情况。如果$p[k]!=p[i-1]$怎么办呢？这时候，你可能会想到：能不能把相等的前缀和后缀缩短一些，好让他们后面的一个字符能相等？如果能，缩短多少好呢？

这里我们有一个操作：$k=next[k]$。想一想，为什么这么做？

别忘了，我们的$k$也是有$next$值的。并且，回顾我们的过程：$k$前面的字符串和$i-1$前面的字符串是相同的。如果你调取$next[k]$，你就获得了一段前缀，它既等于$k$前面的一顿后缀，又等于$i-1$前面的一段后缀。巧妙之处就在于此：相等的对称性。我们有相等的大前缀和大后缀，而从大前缀中取出的相等的小前缀和小后缀，可以平移到大后缀上面去。

如此，我们只要递归到$p[k]==p[i-1]$，或者不再有相等的前后缀为止。

总结一下，就是：模式串$p$移动的距离变成了$j-next[j]$，并且会从$p[next[j]]$开始匹配。

既然大体上我们已经明白$next$数组怎么求，我就贴一波代码：

void Get_Next(string p){
	int len = p.size() ;
	int j=0, k=-1 ; //j,k分别代表当前比较的两个字符的位置 
	Next[0] = -1 ;
	while(j < len-1 ){
		if(k == -1 || p[k] == p[j]){
			j++ ; k++ ;
			if(p[k] != p[j]){
				Next[j] = k ;
			}
			else {
				Next[j] = Next[k] ;
				//本来是要递归直到p[k] != p[j]的,但是发现Next[j]之前已经求过了 
				//也就意味着p[j] == p[k] != p[Next[k]]
				//也就是k = Next[k], Next[j] = k
				//简化成Next[j] = Next[k]
				//但是其实不能写成第一种
				//第二种写法没有改变k,因为下一组还要用p[j] == p[k] 
				//如果改变了k,那么Next[j+1]就有可能不对了.p[j+1] 不一定等于 p[k+1] 
			}
		}
		else {
			k = Next[k] ;
		}
	}
}

这里，$next$数组的求法和上文所说有一些不同。

1. 在$next$数组中设为$-1$的位置，说明不仅$p[j]$前面没有相等的前后缀，并且就连$p[0]$也和要比较的$s[i]$不相等。那么我们只好在$j=-1$时把$i$向后移动，同时令$j+1$，这样从下一位重新开始匹配。
2. 按照上文的思路，代码应该是这样的：

if(k == -1 || p[k] == p[j]){
			j++ ; k++ ;
			Next[j] = k ;

但是这样会有问题。不是思路上的错误，而是会造成时间浪费。
思考：匹配时遇到了$p[j]!=s[i]$。如果$p[j]==p[next[j]]$，那么$p$移动过来之后，匹配照样会失败。必须换一个字符，匹配才有成功的可能。也就是说，我们在选定$next$的时候，不能让$p[j]==p[next[j]]$。在这里，又要使用我们的递归方法了，直到找到$p[k]!=p[j]$的k为止，然后设定$next[j]=next[k]$。具体在写代码的时候，并没有写成递归，原因在上面的注释中可以看到。

具体实现——模式串匹配

有了$next$数组，匹配就变得简单快捷了。

void KMP_Match(string s, string p){
	int i=0, j=0 ;
	int len_s = s.size(), len_p = p.size() ;
	while(i < len_s ){
		if(j == -1 || s[i] == p[j]){
			i++ ; j++ ;
		}
		else {
			j = Next[j] ;
		}
		if(j == len_p ){
			j = 0 ;
			i -= len_p-1 ; 
			//出现了匹配成功的例子
			//j回到开头0,i则跳转到这次匹配开始的后一个位置 
			printf("%d\n", i-1 ) ;
		}
	}
}

这就是全部的匹配代码，比暴力匹配也长不了多少，但是在时间上却实现了巨大的突破。