[学习笔记] KMP算法——烤馍片（超详细）

1. KMP简介

kmp算法，是一种线性字符串匹配（父子串为 root，子子串为 s），由 D.E.Knuth，J.H.Morris 和 V.R.Pratt 提出的，因此人们称它为KMP算法。

2. 暴力思路

举个样例吧。

下标	1	2	3	4	5	6	7	8	9
root	a	b	c	a	a	b	c	a	b
s	a	b	c	a	b

拿到这个串，我们让两个指针 \(l,r\) 分别指向 \(root\) 和 \(s\)。

共 \(len(root)\) 轮，对于第 \(i\) 轮，让 \(l\gets i,r\gets 1\)，并执行按顺序执行以下操作：

• 如果 \(r=len(s)\) 则找到 \(s\)。
• 如果 \(r\ne len(s)\) 且 \(root_l=s_r\)，则 \(l\gets l+1,r\gets r+1\)，并重复该操作。
• 如果 \(root_l\ne s_r\)，则跳过该阶段。

就拿样例而言，对于第 \(1\) 轮，\(l=1,r=1\)，发现 \(root_1=s_1\)，则 \(l+1,r+1\)。当 \(l=5,r=5\) 时，\(root_5\ne s_5\)，则进行第2轮，\(l=2,r=1\)......

你会发现，一旦中途不符合条件，已知的信息最会浪费。那有没有不浪费已知信息的算法呢？

答案是有的，那就是烤馍片算法。

3. KMP算法

3.1 过程

再来举个样例：

下标	1	2	3	4	5	6	7	8	9	10	11	12
root	A	B	C	D	A	B	C	D	A	B	C	E
s	A	B	C	D	A	B	C	E

我们匹配好前面八位的时候，发现第九位不对，我们就移动 \(s\)，根据前面已知的，我们就可以像下面这样：

下标	1	2	3	4	5	6	7	8	9	10	11	12
root	A	B	C	D	A	B	C	D	A	B	C	E
s					A	B	C	D	A	B	C	E

直接向后移动四位，然后我们的 \(l\) 继续从第五位开始，直到匹配成功。

注意：我们都是判断 \(l\) 和 \(r\) 下一个位置是否为相同。

前缀串与后缀串

如 abcde：

前缀串：a,ab,abc,abcd,abcde

后缀串：e,de,cde,bcde,abcde

其实，\(r\) 只是回跳到使得 \(root\) 前 \(l\) 段的后缀与 \(s\) 前 \(r\) 段的前缀相等的最长长度的位置（除了自己），有点长，大家可以分开理解。

例如，当 \(l=8,r=8\) 时，下一个位置不一样，则将 \(r\) 回退到 \(3\)，因为 \(root\) 前 \(8\) 个中的倒数 \(3\) 个与 \(s\) 前 \(4\) 个中的前面 \(3\) 个一样都是 \(ABC\)，所以回退到 \(3\)。

这里，我们为了预处理，简化一下，来发下一下性质。还是这个例子：

下标	1	2	3	4	5	6	7	8	9	10	11	12
root	A	B	C	D	\(\red{A}\)	\(\red{B}\)	\(\red{C}\)	D	A	B	C	E
s	\(\green{A}\)	\(\green{B}\)	\(\green{C}\)	D	\(\purple{A}\)	\(\purple{B}\)	\(\purple{C}\)	E

我们要用到的是红色和绿色的字母，这里就是最长公共前后缀。但是，大家想一想，紫色部分和红色部分是不是一模一样的呀，因为指针能到 \(7\)，肯定是因为紫色部分和红色部分一样。

那这样子，紫色和红色一样，红色和绿色一样，那绿色就和紫色一样！这样，我们就只需要预处理 \(s\) 就可以了。

3.2 具体实现

到这里，我们可以写出伪代码（\(next\) 为 \(s\) 的最长公共前后缀）：

if root[l] = s[r] then
	l <- l + 1, r <- r + 1
else then
	r <- next[r]

那怎么预处理 \(next\) 呢？再举一个例子：

下标	1	2	3	4	5	6	7	8	9	10	11
s	a	b	a	b	\(\red{e}\)	f	a	b	a	b	_

next[0]=0
next[1]=0
next[2]=0
next[3]=1
next[4]=2
next[5]=0
next[6]=0
next[7]=1
next[8]=2
next[9]=3
next[10]=4

我们试着用动态规划的思想，已知 \(next_{1\sim10}\)，求 \(next_{11}\)。

已知：\(s_{1\sim4}=s_{7\sim10}\)。

• 如果 \(s_5=s_{11}=e\)，那么 \(next_{11}=next_{10}+1\)。
• 如果 \(s_{11}=a\)，那么，取次长公共前后缀，就是 \(ab\)，长度为 \(2\)，就是 \(next[next[10]]\)，刚好可以与 \(a\) 搭配，形成 \(aba\)，则 \(next_{11}=next_{next_{10}}+1=3\)。
• 如果 \(s_{11}=x\)，什么都不是，那就只能是 \(0\)了。可以转化为不断地取次长公共前后缀，但是都不符合，最后变成 \(0\) 了而已。

综上，我们得出，只要 \(s_{i+1}\ne s_{r+1}\)，就让 \(r\gets next_r\)，前提是 \(r\ne0\)。

最后就让 \(next_{i+1}=next_{r}+1\) 就行咯。

代码：

inline void init() {
    nex[0] = nex[1] = 0; // 初始化
    int m = t.size();
    for (int i = 1, j = 0; i < m; i++) { // 求 nex[i+1]
        while (j && s[i + 1] != s[j + 1]) j = nex[j]; // 取次长
        if (s[i + 1] == s[j + 1]) j++; // 为什么不统一+1？因为上面可能是因为j=0而终止的。
        nex[i + 1] = j;
    }
    return;
}

例题

求出现位置与 \(next\) 数组。

代码：

// Problem: P3375 【模板】KMP
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P3375
// Memory Limit: 512 MB
// Time Limit: 1000 ms
//
// Powered by CP Editor (https://cpeditor.org)

/*+ Nimbunny +*/

#include <bits/stdc++.h>
#define endl '\n'
#define pi pair<int, int>
// #define int long long
// #pragma GCC optimize(2)

using namespace std;
const int INF = INT_MAX;
const int mod = 1e9 + 7;
const int N = 1e6 + 10;
string root, s;
int n, m, nex[N];

inline int read() {
    int x;
    cin >> x;
    return x;
}

inline void init() {
    nex[0] = nex[1] = 0; // 初始化
    for (int i = 1, j = 0; i < m; i++) { // 求 nex[i+1]
        while (j && s[i + 1] != s[j + 1]) j = nex[j]; // 取次长
        if (s[i + 1] == s[j + 1]) j++; // 为什么不统一+1？因为上面可能是因为j=0而终止的。
        nex[i + 1] = j;
    }
    return;
}

signed main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    cin >> root >> s;
    n = root.size(), m = s.size();
    root = "#" + root, s = "#" + s;
    init();
    for (int l = 0, r = 0; l < n; l++) {
        while (r && root[l + 1] != s[r + 1]) r = nex[r];
        if (root[l + 1] == s[r + 1]) r++;
        if (r == m)
            cout << l + 1 - m + 1 << endl; // 因为l还没有+1，所以l要先+1
    }
    for (int i = 1; i <= m; i++) cout << nex[i] << " ";
    return 0;
}

3.3 时间复杂度

鸽子咯咯咯子鸽。