KMP算法——深入骨髓的领悟

前缀函数与KMP算法

作者：@魔幻世界魔幻人生
本文为作者原创，转载请注明出处：https://www.cnblogs.com/subtlemaple/p/16618392.html

Top

前缀函数与KMP算法

真前缀： S中不全等于S的前缀

前缀函数定义

$s [0 \dots i]$ 的真前缀与真后缀相等的最大长度为 $π (i)$ 。

规定 $π (0) = 0$ 。

计算前缀函数

1.朴素算法

按照定义 , 按 $i = 1 \dots n - 1$ 计算 $π (i)$ 。

令长度 $j$ 从最大前缀长度 $i$ 开始一直到 $0$ 。

用 $s u b s t r ()$ 截取 $s [0 \dots j - 1]$ 和 $s [i - j + 1, i]$

若相等，则 $π (i) = j$ ，否则 $j - -$ ,直到 $j < 0$ 时， $π (i) = 0$ 。

代码

vector<int> prefix_function(string s)
{
	int n = s.length();
	vector<int> pi(n);
	for(int i=1;i<n;++i) {
		for(int j=i;~j;--j)
		{
			if(s.substr(0,j) == s.substr(i-j+1,j))
			{
				pi[i] = j;
				break;
			}
		}
	}
	return pi;
}

2.优化一

$π (i + 1) <= π (i) + 1$ ;

因为相当于在 $s [0 - i]$ 后加了一个 $s [i + 1]$ ,最大后缀最多增加 $1$

所以相对于前一段代码 $j = i \dots 0$ ，优化为 $j = π (i - 1) + 1 \dots 0$ 。

代码：

vector<int> prefix_function(string s) {
  int n = (int)s.length();
  vector<int> pi(n);
  for (int i = 1; i < n; i++)
    for (int j = pi[i - 1] + 1; j >= 0; j--)  // improved: j=i => j=pi[i-1]+1
      if (s.substr(0, j) == s.substr(i - j + 1, j)) {
        pi[i] = j;
        break;
      }
  return pi;
}

3.优化二

第一个优化中，我们考虑了 $π (i + 1) = π (i) + 1$ 的最优情况，那么当最优情况不成立时，跳转到一个次优情况。

我们找到仅次于 $π (i)$ 的第二长度 $j$ ,使 $s [0 \dots j - 1] = s [i - j + 1 \dots i]$ 。

显然 $j$ 是此时的最好选择。

这时若 $s [j] = s [i + 1]$ ，那么 $π (i + 1) = j + 1$ 。

如下图：

可以看出， $j$ 等价于 $s [0 \dots π (i) - 1]$ 的前缀函数，即 $j = π (π (i - 1))$ ；同理，次于 $j$ 的第二长度 $j^{(2)} = π (j - 1)$ 。

得到关于 $j$ 的状态转移方程：

$j^{(n)} = π (j^{(n - 1)} - 1)$ , $j^{(n - 1)} > 0$ 。

终极算法：

vector<int> prefix_function(string s)
{
    int n = s.length();
    vector<int> pi(n);
    for(int i = 1; i < n ; i++)
    {
        int j = pi[i-1];
        while(j>0 && s[i]!=s[j]) j = pi[j-1];
        if(s[i]==s[j]) ++j;//找到了满足条件的 j,j++后从i-1转移到 i
        pi[i] = j;
    }
    return pi;
}

前缀函数应用：KMP算法

对于一个文本 $s_{1}$ 和一个匹配串 $s_{2}$ ，求出 $s_{2}$ 在 $s_{1}$ 中所有出现的位置。

解法：

将 $s_{2}$ 和 $s_{1}$ 放在一个串 $s$ 里，用分隔符隔开。设 $s_{2}$ 长度为 $n$ 。

对 $s$ 求前缀函数，由于分隔符(位置在 $n$ )的存在， $n$ 以后的所有 $π (i)$ 都不可能超过 $n$ ,当 $π (i) == n$ 时，意味着最长前缀等于最长后缀，且最长前缀长度为 $n$ ,这个最长前缀就是 $s_{2}$ 。

那么 $s_{2}$ 在 $s_{1}$ 中的位置就是 $i - 2 \times π (i)$ ，下标 $0$ 开始。

洛谷P3375 【模板】KMP字符串匹配

代码：

#include<iostream>
#include<string>
#include<vector>
#include<cstdio>
using namespace std;
const int maxn = 1e6+7;
string s1,s2;
void prefix_function(string s,vector<int>& pi) // pi直接传进函数里
{
	int n = (int)s.length();
	for(int i = 1; i < n; ++i) 
    {
    	int j = pi[i-1];
		while(j>0 && s[i]!=s[j]) j = pi[j-1];
		if(s[i]==s[j]) ++j;
		pi[i] = j; // 若 j = 0 ,则说明 s[i] != s[j] 
    }
    return ;
} 
int main()
{
	freopen("data.in","r",stdin);
	string s;
	cin>>s1>>s2;
	s = s2 + '$' + s1; // 分隔符隔开
	//cout<<s<<endl; 
	int lens2 = (int)s2.length();
	int n = (int)s.length();
	//cout<<lens2<<" "<<n<<endl;
	vector<int> pi(n);
	prefix_function(s,pi);
	for(int i=lens2+1;i<=n;++i) // 下标0
	{
		if(pi[i] == lens2)
		{
			printf("%d\n",i-2*lens2+1);
		} 
	} 
	pi.clear();
	prefix_function(s2,pi);
	for(int i=0;i<lens2;++i) 
	{
		cout<<pi[i]<<" ";
	} 
	return 0;
}

$e n d$

.......了吗？

被巨佬拜访后,我重审了KMP，发现 OI-Wiki 上的做法不是 KMP 的理解方式，只是对前缀函数的naive使用。

实际上 KMP 算法的流程：

对模式串求 pi，计入pi数组；
拿模式串和文本串匹配长度 $j$ ;

这两个过程本质都是求前缀函数，只是一个是自己匹配自己，另一个是自己匹配别人。

同时，在 KMP 算法里， $π$ 数组被称为 失配数组，正如它的名字，当匹配不成立时，失配数组中的值就是当前次优状态，通过失配数组跳至这个次优状态。

代码：

#include<iostream>
#include<string>
#include<vector>
#include<cstdio>
using namespace std;
const int maxn = 1e6+7;
int ls,lt;
void prefix_function(string s,vector<int>& pi) // pi直接传进函数里
{
	int n = (int)s.length();
	for(int i = 1; i < n; ++i) 
    {
    	int j = pi[i-1];
		while(j>0 && s[i]!=s[j]) j = pi[j-1];
		if(s[i]==s[j]) ++j;
		pi[i] = j; // 若 j = 0 ,则说明 s[i] != s[j] 
    }
    return ;
} 
string s,t;
void match(vector<int>& pi)//模式串匹配文本串
{
	int j=0;
	for(int i=0;i<ls;++i)
	{
		for(;j&&s[i]!=t[j];j=pi[j-1]);
		if(s[i]==t[j]) ++j;
		if(j==lt) printf("%d\n",i-lt+2); 
	}
}
int main()
{ios::sync_with_stdio(0);
	cin>>s>>t;
	ls = (int)s.length(); 
    lt = (int)t.length();
    vector<int> pi(lt);
    prefix_function(t,pi);
    match(pi);
    for(int i=0;i<lt;++i) printf("%d ",pi[i]);
	return 0;
}

为了与国际接轨，我从 2022/07/13 开始做出以下规定：

字符串下标 0 开始；
$p i [i]$ 表示长度为 $i$ 的前缀的失陪长度；

这样，KMP的模板就变成了：

void get_KMP(string s)
{
    int n = (int)s.length();
    int j  = 0; //请注意，j是当前匹配长度
    pi[0] = 0;
    for(int i=1;i<n;++i)
    {
        while(j&&s[i]!=s[j]) j = pi[j];//
        j+=(s[j]==s[i]);
        pi[i+1] = j; // i 是下标，i+1 是长度 
    }
}

神题：P2375 [NOI2014] 动物园

这题让求每个前缀的不重叠KMP个数。

即 $最长前后缀 \leq l e n / 2$ ；

那么从下标 $0 \dots n - 1$ 重新依次匹配，原来求得的 $p i$ 不能再用；

因为原先的 $p i$ 可能包含重叠区域，而我们要的最长前后缀不能有重叠；

所以根据KMP的思想，用现在的合法最长前后缀推下一个；

题目要求每个前缀的所有不重叠匹配串，

假如 $j$ 长度合法 , 那么下一个合法的就是 $p i [j]$ , 下下个就是 $p i [p i [j]]$ $\dots$ 一直到 $0$ (0不计数)

$n u m$ 数组实际上是当前的 $j$ 能跳失配指针几次到 0 ；

而板子中 $p i [i + 1] = j$ ,正是把 $i + 1$ 的失配指针作为 $j$ 。

所以 $n u m$ 的递推方式是: num[i+1]=num[j]+1;

此题就完结了；

代码:

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int maxn = 1e6+3;
const int mod = 1e9+7;
int pi[maxn],num[maxn],pre[maxn];
void get_KMP(string s)
{
	int j=0; pi[0]=0; pre[0] = 0, pre[1] = 1;
	int n = (int)s.length();
	for(int i=1;i<n;++i)
	{
		while(j && s[i]!=s[j]) j = pi[j];
		if(s[i]==s[j]) ++j;
		pi[i+1] = j;
		pre[i+1] = pre[j] + 1; //递推
    }
}
signed main()
{ios::sync_with_stdio(0);
	int T; cin>>T;
	for(;T--;)
	{
		string s;
		cin>>s;
		int n = s.length();
		memset(pi,0,sizeof(pi));
		memset(pre,0,sizeof(pre));
		memset(num,0,sizeof(num));
		get_KMP(s);
		int ans = 1;
		int j=0;
		for(int i=1;i<n;++i)
		{
			while(j && s[i]!=s[j]) j = pi[j];
		    if(s[i]==s[j]) ++j;
			while(j+j > (i+1)) j=pi[j];
			ans = (ans * (pre[j]+1) %mod);
		} 
		cout<<ans<<'\n';
	}
	return 0;
}