KMP字符串匹配

KMP是一个单串匹配$O(n)$的算法，不同于Hash，这个是保证正确的。
什么是单串匹配呢？就是给你一个模式串P和一个文本串T，问P在T中的哪些位置出现过。
暴力做法就是把T的每个位置都跟P匹配一遍，复杂度为$O(len(T)*len(P))$，也就是$O(nm)$。
以下，因为公式化的引号（包括单引号和双引号）不好看，所以单个字符或字符串的两边都没有引号。
我们发现，有些位置我们会匹配重复很多遍，浪费大量的时间。比如说，当$P = aaab, T = aaaab$时，前三个a都能匹配上，到第四个字符发现a不等于b时，我们就得重头再来，而不是利用之前能够匹配上的三个a。
那怎样尽可能减少这种无意义的匹配呢？
介绍一下KMP的核心：next数组。next[i]代表模式串中第0位到第i-1位的最长公共前后缀的长度，也就是当前位置失配后应当匹配的下一个。试想一下，假如next[i] = x，就意味着第0位到第x-1位和第i-x位到第i-1位是一样的，那么当你在第i位匹配失败了，你就直接跳到第x位匹配不就很好吗？
下面举个例子：
$0$ $1$ $2$ $3$ $4$ $5$
$a$ $b$ $d$ $a$ $b$ $c$
$a$ $b$ $d$ $a$ $b$ $d$ $a$ $b$ $c$
其中，第一行是$i$，第二行是$P[i]$，第三行是$T[i]$。
模拟一下匹配过程：
维护两个指针$i, j$进行匹配，其中$i$维护T当前的位置，$j$维护$P$当前的位置，初值均为0；
发现$P[0] = T[0]$，则$i, j$两个指针都加1，此时$i = j = 1$；
发现$P[1] = T[1]$，则$i, j$两个指针都加1，此时$i = j = 2$；
$……$
发现$P[4] = T[4]$，则$i, j$两个指针都加1，此时$i = j = 5$；
紧接着，$P[5] \neq T[5]$，我们有$P[0] = P[3] = a, P[1] = P[4] = b$，因为$P[3], P[4]$与$T[3], T[4]$能够成功匹配，就意味着$P[0], P[1]$与$T[3], T[4]$也能成功匹配，所以$P[5]$匹配失败后，我们就可以用$P[2]$去试试，即$j = next[j] = 2$。
然后一路顺风顺水地就匹配完了。

Code

#include <iostream>
#include <cstring>
#include <cstdio>

const int maxn = 1e6 + 7;

using namespace std;

int n;
char t[maxn];
char p[maxn];
int nex[maxn];

inline void get_next(char *p, int *nex)
{
    int i = 0, j = -1;
    nex[0] = -1;
    while (p[i]) {
        if (j < 0 || p[i] == p[j]) nex[++i] = ++j;
        else j = nex[j];
    }
}

inline void kmp(char *t, char *p)
{
    for (int i = 0, j = 0; t[i]; i++) {
        while (~j && t[i] != p[j]) j = nex[j];
        j++;
        if (j == n) printf("%d\n", i - n + 2);
    }
}

int main(void)
{
    scanf("%s%s", t, p);
    n = strlen(p);
    get_next(p, nex);
    kmp(t, p);
    for (int i = 1; i <= n; i++) printf("%d ", nex[i]);

    return 0;
}