KMP 算法学习笔记

KMP 字符串匹配算法

一个人最可悲的地方不在于失败，而在于失败后，不去尝试找回曾经的自己而是直接推倒重来。—— KMP

$\mathtt{一些定义}$

• $s(i)$ 为字符串 $s$ 从左往右第 $i$ 个字符，$s(l,r)$ 为 $s$ 从左往右第 $l$ 个字符到从左往右第 $r$ 个字符所构成的子串。

  例：设 s="abcdefg"，则 $s(2)$ 为 b，$s(3,5)$ 为 cde。

• $t$（长度为 $m$）的最长前后缀长度的定义：使得 $t(1,k)$ 与 $t(m - k + 1, m)$ 相等的最大 $k$​​​​​​ 值。

• 长度为 $j$ 的前缀指 $s(1,j)$，假设 $s$ 长度为 $k$，则长度为 $j$ 的后缀指 $s(k - j + 1, k)$。

• 本文代码如无特殊说明，默认已经执行过：

  cin >> (a + 1) >> (b + 1);
  n = strlen(a);
  m = strlen(b);

$\mathtt{引入：抽象的暴力算法形式}$

KMP 所解决的问题非常简单：给定主串 $A$，模式串 $B$，问 $B$ 在 $A$ 中：

• 出现了多少次？
• 出现在什么位置上？

这个问题暴力做非常简单，上代码：

for(int i = 1;i + m - 1 <= n;i++)
{
    bool ok = 1;
    for(int j = i;j <= i + m - 1;j++)
    {
        if(a[i] != b[j])
        {
            ok = 0;
            break;
        }
    }
    if(ok) /*在位置 i 上匹配到，进行处理*/
}

这个暴力做法很显然，基本上一看代码就知道它的作用，接下来我们对它进行一些改动，以便于为下文的 KMP 算法做铺垫。

改动一：把 $i$ 改成指针的形式，并修改定义。

我们定义 $i$ 不再是子串的第一个字符的位置，而是子串最后一个字符的位置。

int i = 0;
while(i <= n)
{
    if(i - m + 1 < 1) continue;
    bool ok = 1;
    for(int j = i - m + 1;j <= i;j++)
    {
        if(a[i] != b[j])
        {
            ok = 0;
            break;
        }
    }
    if(ok) /*在位置 i 上匹配到，进行处理*/
    i++;
}

改动二：把 $j$ 也改成指针的形式，并修改定义

$j$ 代表：$a(i - j + 1,i)$ 与 $b(1,j)$​ 完全相等。

注意到此时我们就需要让 $i$ 和 $j$ 同步变化，也就是说，当 $a(i + 1)$ 等于 $b(j + 1)$ 时，$i$ 和 $j$ 各加上 $1$，这样子才能保持 $i$ 和 $j$ 的定义，建议手推一下以更好的理解。

int i = 0, j = 0;
while(i < n && j < m)
{
    if(a[i + 1] == b[j + 1])
    {
        i++;
        j++;
    }
    else
    {
        i = i + 2 - j;
        j = 0;
    }
    if(j == m)
    {
        /*在 i + 1 - m 上匹配到*/
        j = 0;
    }
}

算法流程大致如下：

• 如果 $a(i + 1)$ 和 $b(j + 1)$ 相等，说明可以继续匹配下去，各加上 $1$。
• 如果不相等，说明匹配不下去了，$j$ 直接跳回 $0$，$i$ 回到最开始的地方的下一位（也就是 $i - j +1 +1 = i-j+2$，因为你现在匹配了 $j$ 位，跳回去就是 $i -j + 1$，它的下一位就是 $i - j + 1+ 1$）。
• 如果 $j=m$，说明匹配成功，将 $j$ 设为 $0$，从当前的 $i$ 开始继续匹配（因为很可能会匹配多次，从 $i$​ 开始是因为前面都已经匹配过了）。

这个算法的复杂度为 $O(nm)$，有点慢，慢在哪呢？

$\mathtt{优化：KMP\ 算法}$

这个时候 K、M、P 三个人站了出来：慢在让 $i$ 直接跳回去！

他们说，本来前面就已经匹配了那么多，现在一匹配不下去就要舍弃前面所有的匹配成果重新再来，这也太浪费了！

怎么办？他们提出了一个大胆的想法：让 $i$ 不跳。

你可能会说，$i$ 不跳？那这样不就无法保证匹配了吗？

别急，你想想，$i$ 动不了，我们是不是可以通过调整 $j$，来使得在 $i$ 不变的前提下，其依旧满足呢？注意，$j$ 调整后要尽量大哦。（如果小的话跟直接调成 $0$​ 就没啥区别了）

显然可以，这就是 KMP 算法的核心：通过调整 $j$，使得在 $i$ 不变的前提下，$i$ 和 $j$​ 依旧满足定义。

显然，$j$ 一定是变小的，因为变大的话，无法保证匹配。（本来下一位就无法保证匹配了，现在你还变大，相当于给后面可能无法匹配的位置强行搞成匹配）

KMP 提出了一个 $\text{next}(i)$ 数组，他发现，这个数组与 $A$ 无关，它的基本定义为：

当第 $i$ 位可以匹配，第 $i + 1$ 位无法继续匹配时，在 $j$ 继续符合定义，即 $a(i - j + 1,i)$ 与 $b(1,j)$ 完全相等的情况下，能调整到的最大的 $j$ 是多少？

KMP 算法和上面所讲的暴力算法非常类似，过程如下：

• 如果 $a(i + 1)$ 和 $b(j + 1)$ 相等，说明可以继续匹配下去，各加上 $1$。
• 如果不相等，说明匹配不下去了，$j$ 跳回 $\text{next}(j)$，$i$ 不变。
• 如果 $j=m$，说明匹配成功，将 $j$ 设为 $\text{next}(j)$（因为很可能会匹配多次）。

这里无非就是把“跳回 0”这个动作改成了“跳回 $\text{next}(j)$”，并让 $i$ 保持不变，这样的好处就在于，匹配失败一个位不会立刻推倒重来，而是会跳到先前的一部继续匹配。

代码实现时需要注意：由于第二步 $i$ 不变，因此可以进行一个小小的改动：

• 如果 $a(i +1)$ 和 $b(j + 1)$ 不相等，一直让 $j=\text{next}(j)$，直到 $j = 0$​ 或相等为止。

（下文都称 $\text{next}$ 数组为 $p$ 数组）

由于不相等时总是会回到第二步，相当于一个循环，因此这个改动是正确的，代码如下：

while(j > 0 && b[j + 1] != a[i + 1]) j = p[j];

综合其它两步，实现如下：

while(j > 0 && b[j + 1] != a[i + 1]) j = p[j];
if(a[i + 1] == b[j + 1])
{
    i ++;
    j++;
}
if(j == m)
{
    /*i - m + 1 上可以匹配到*/
    j = p[j];
}

是不是和暴力很相似？没错，KMP 和暴力的唯一不同就在于使用了 $\text{next}$ 数组避免了反复推倒重来所带来的无谓的时间消耗。

最后注意到 i++ 可以放到代码的末尾，这样子我们就可以把代码简化成 for 循环了，但需要注意：$j=m$ 时，匹配位置的 $i$ 改之后会少掉一，因此答案就需要加上一个一，具体看代码：

int j = 0;
for(int i = 0;i < n;i++)
{
    while(j > 0 && b[j + 1] != a[i + 1]) j = p[j];
    if(a[i + 1] == b[j + 1]) j++;
    if(j == m)
    {
        /*i - m + 2 上可以匹配到*/
        j = p[j];
    }
}

问题又来了，$\text{next}$ 数组怎么求呢？

$\mathtt{next\ 数组的新定义}$

看图说话：

$\mathtt{next\ 数组的求法}$

下文代码默认已经执行过：

strcpy(s, b);

我们不妨来举个例子：

$$\large{\mathtt{ABACABAB}}$$

我们刚刚已经证明，$p_i$​ 的定义为：

$p_i$ 代表 $s(1,i)$ 的最长前后缀的长度。

也就是说，我们要去获取 $1\le i \le n$ 中 $s(1,i)$ 这个子串的最长前后缀长度。

怎么求？我们可以一位一位地去求。具体地，不妨假设 $s(1,i-1)$ 的最长前后缀长度为 $j$，也就是说当前匹配了 $j$ 位的前后缀，那么如果 $s(i) = s(j + 1)$，$s(1,i)$ 的最长前后缀的长度就是 $j+1$，如下图：

为了防止 $i-1$ 下标越界，在写代码时，我们可以将上面的话换一种表达方式：设 $s(1,i)$ 的最长前后缀长度为 $j$，那么如果 $s(i + 1) = s(j + 1)$ ，$s(1,i+1)$ 的最长前后缀的长度就是 $j+1$。写成代码大概长这样：

for(int i = 1;i < m;i++)
{
    if(s[i + 1] == s[j + 1]) j++;
    p[i + 1] = j;
}

那么如果不同呢？你想想，如果 $s(i + 1) \neq s(j+1)$ ，那么是不是意味着我们就要重头再次开始匹配，也就是让 $j = 0, i = 1$ 呢？当然不是！前面匹配了那么多肯定不能白费，既然前后缀长度为 $j$ 无法继续匹配，那么我们就去找 $s(1,j)$ 的最长前后缀。由于 $s(1,j) = s(i - j + 1,i)$，那么这个最长前后缀其实就是 $s(1,j)$ 的前缀与 $s(i - j + 1,i)$ 的后缀的不包括它们本身的最长公共串！（你可以把 $s(i - j + 1,i)$ 的后缀看成是 $s(1,j)$ 的后缀）那么既然它们是公共的，也就是说它就是前后缀（只不过不是最长的而已，是第二长，第一长是 $s(1,j)$）那么让 $j$ 等于它继续匹配即可，因为它刚好是第二长，而又由于第一长匹配不下去，那么它继续匹配下去必然是最长前后缀。当然，如果第二长的也匹配不下去，那就换成第二长的最长前后缀，也就是第三长的继续匹配，理由同上。那么我们就只需要当下一位（$s(i + 1)$ 和 $s(j+1)$）匹配不上时，不断地使 $j=p(j)$，找到可以匹配的那个 $j$ 就可以啦！写成代码就是：

for(int i = 1;i < m;i++)
{
    while(j > 0 && s[i + 1] != s[j + 1]) j = p[j];
    if(s[i + 1] == s[j + 1]) j++;
    p[i + 1] = j;
}

然后 $p$ 数组就被求出来啦！注意，$j$ 的初值是 $0$ 哦！

$\mathtt{代码实现}$

for(int i = 1;i < m;i++)
{
    while(j > 0 && s[i + 1] != s[j + 1]) j = p[j];
    if(s[i + 1] == s[j + 1]) j++;
    p[i + 1] = j;
}
 
int j = 0;
for(int i = 0;i < n;i++)
{
    while(j > 0 && b[j + 1] != a[i + 1]) j = p[j];
    if(a[i + 1] == b[j + 1]) j++;
    if(j == m)
    {
        /*i - m + 2 上可以匹配到*/
        j = p[j];
    }
}