KMP算法详解

-1.前置约定

如非特殊说明，以下文字中$T$代表主串，$P$代表模式串，$m$代表主串长度，$n$代表模式串长度

真前缀 一个字符串除了它本身之外的前缀。例如，moo 是 moon 的真前缀，moon 却不是。真后缀同理。

“border” 如果字符串 $a$ 既是 $b$ 的真前缀，又是 $b$ 的真后缀，那么我们说 $a$ 是 $b$ 的 border。

0.什么是KMP？

KMP算法是一种改进的字符串匹配算法，由D.E.Knuth，J.H.Morris和V.R.Pratt提出的，因此人们称它为克努特—莫里斯—普拉特操作（简称KMP算法）。KMP算法的核心是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是通过一个next()函数实现，函数本身包含了模式串的局部匹配信息。KMP算法的时间复杂度$O(m+n)$。——摘自百度百科

简而言之，它可以在 $O(m+n)$ 的时间复杂度之内在主串 $T$ 中找到所有模式串 $P$，非常优秀。

1.正文

1.1.求$next$数组

KMP算法需要求一个“$next$数组”，$next_i$= $P_{1...i}$ 最大的border的长度

注意到border有一些很好的性质，例如：

1. 传递性。如果 $a$ 是 $b$ 的 border， $b$ 是 $c$ 的 border，那么 $a$ 是 $c$ 的 border。
2. 如果 $a$ 是 $s$ 的 border,那么比 $a$ 小的最大 $s$ 的 border 一定是 $a$ 的最大 border。 换句话说，把 $s$ 的所有 border 从大到小排序，那么在后面的 border 也是在前面的 border 的 border。

根据上面两个性质可以推出这样一个有趣的结论：如果知道 $next_{1...i-1}$ ，就可以找出字符串的所有 border ！

所以 $next_i$ 、 $next_{next_i}$ 、 $next_{next_{next_i}}$ ......是所有字符串 $P_{1..i}$ 的 border 的长度。老套娃了

于是我们可以根据这个性质递推出 $next$ 数组。

根据 $next$ 数组的定义，显然有 $next_1=0$。

假设 $next_1$ 到 $next_{i-1}$都已经被求出来了。如果当前要求 $next_i$ ，我们只需让 $j$ 依次等于 $next_{i-1}$ 、 $next_{next_{i-1}}$ 、 $next_{next_{next_{i-1}}}$...... （$P_{1...i-1}$ 所有 border 的长度），因为 border 的定义， $P_{1...j}==P_{i-j...i-1}$ 总是成立，所以如果 $P_{j+1}==P_{i}$ ，就说明 $P_{1...j+1}==P_{i-j...i}$ ，即找到了 $P_{1..i}$ 的一个 border。

不难看出，最先找到的 border 一定是最大的 border ,即 $next_i$。

于是可以写出求 $next$ 数组的代码：

next[1]=0;
for(int i=2;i<=n;i++){
    int j=next[i-1];
    while(j>0&&p[i]!=p[j+1]){
        j=next[j];
    }//让j依次等于P[1...i-1]的所有border
    if(p[i]==p[j+1]){
        j++;
    }
    next[i]=j;
}

1.2.匹配

先来看看暴力算法的思路。

然而我们可以发现，它的时间复杂度甚至达到了$O(mn)$。在暴力算法中，如果发生了失配（即匹配到半路发现有一个字符不相等），只能把模板串往后移1位再重新开始匹配。这样做效率实在太低了，有什么办法优化吗？

当然有！

如果发生下列情况：

可以直接把模板串后移 $j-next_j$ 位，即令 $j$ 赋值为 $next_j$。如果仍然失配，就重复以上过程，直到匹配成功为止，然后进行下一轮匹配。

这个东西跟求 $next$ 数组思想类似，代码肯定也类似啦233

代码：

for(int i=1,j=0;i<=m;i++){
    while(j>0&&t[i]!=p[j+1]){
        j=next[j];
    }
    if(t[i]==p[j+1]){
        j++;
    }
    if(j==n){//匹配成功！OHHHHHHHHHHHHHH！
        cout<<i-j+1<<endl;//输出位置
        j=next[j];//不能躺在功劳簿上睡大觉，重新开始下一轮匹配！
    }
}

1.3 时间复杂度

匹配过程的时间复杂度乍一看很高，因为它有两重循环。实际上，内层循环的执行次数一定不超过 $m$ 次，因为每一次内层循环至少会让 $j$ 减少 $1$，每一次外层循环至多会让 $j$ 加上 $1$，所以内层循环执行次数一定不超过外层循环，即 $m$ 次。所以，不难看出整个匹配过程的时间复杂度为 $\Theta(m)$ 。

求 $next$ 数组过程好像不能通过以上方法分析，然而它还有一种等价写法，也是我常用的写法：

next[1]=0;
for(int i=2,j=0;i<=n;i++){
    while(j>0&&p[i]!=p[j+1]){
        j=next[j];
    }//让j依次等于P[1...i-1]的所有border
    if(p[i]==p[j+1]){
        j++;
    }
    next[i]=j;
}

这样，也不难看出求 $next$ 数组过程的时间复杂度为 $\Theta(n)$

综上，整个 KMP 算法的时间复杂度为 $\Theta(m+n)$，非常快。

2.总结

KMP 算法的精髓在于废旧信息的重新利用和发掘问题性质，同时这也是一个非常烧脑的算法， 非常巧妙。

再附赠一份能通过模板题的代码：

#include <iostream>
#include <cstring>
using namespace std;
#define MAXN 1000000
int nxt[MAXN + 5], n, m;
char t[MAXN + 5], p[MAXN + 5];
int main() {
    ios::sync_with_stdio(false);
    cin >> t + 1 >> p + 1;
    m = strlen(t + 1);
    n = strlen(p + 1);
    nxt[1] = 0;
    for (int i = 2; i <= n; i++) {
        int j = nxt[i - 1];
        while (j > 0 && p[i] != p[j + 1]) {
            j = nxt[j];
        }
        if (p[i] == p[j + 1]) {
            j++;
        }
        nxt[i] = j;
    }
    for (int i = 1, j = 0; i <= m; i++) {
        while (j > 0 && t[i] != p[j + 1]) {
            j = nxt[j];
        }
        if (t[i] == p[j + 1]) {
            j++;
        }
        if (j == n) {
            cout << i - j + 1 << endl;
            j = nxt[j];
        }
    }
    for (int i = 1; i <= n; i++) {
        cout << nxt[i] << ' ';
    }
    return 0;
}

所以，都看到这里了，能给我点一个赞吗（逃