KMP 算法 (Knuth&Morris&Pratt Algorithm)

KMP 算法 (Knuth&Morris&Pratt Algorithm)

找到所有 $s_2$ 作为字符串 $s_1$ 的字串的位置

朴素

枚举 $i$ 作为 $s_1$ 子串起点, $j$ 作为正在比较的字符在 $s_2$ 中的位置, 复杂度 $O(mn)$

Border

定义 border 为一个字符串的真子串, 既是母串的前缀, 又是母串的后缀

设 $a_i$ 为字符串 $s_2$ 的前 $i$ 个字符组成的字符串的最长 border, 尝试 $O(m)$ 求出 $a_i$

首先, 一定有 $a_1 = 0$, 假设对于 $i'$, $a_{i'}$ 已经求出, 则 $a_{i} \leq a_{i - 1} + 1$

首先考虑取等的情况, 当且仅当 ${s_2}_{a_{i - 1} + 1} = {s_2}_i$, 这时可以想象在 $[1, i - 1]$ 的最长 border 之后接上字符 ${s_2}_{a_{i - 1} + 1}$, 构成了一个长度为 $a_{i - 1} + 1$ 的 border

举例

AABAA                 // [1, 5]
AA___ ___AA           // a[5] = 2
AABAAB AAB___ ___AAB  // a[6] = 3

对于原不等式的证明, 使用反证法, 假设 $[1, i]$ 存在长度大于 $a_{i - 1} + 1$ 的 border, 即 $a_i > a_{i - 1} + 1$. 则去掉 ${s_2}_i$ 后, $[{s_2}_1, {s_2}_{a_{i} - 1}]$, 仍是 $[1, i - 1]$ 的一个 border, 长度为 $a_{i} - 1$, 则 $a_{i - 1} = a_i - 1 < a_i$, 假设不成立, 原式得证.

对于 ${s_2}_{a_{i - 1} + 1} \neq {s_2}_i$ 的情况, 根据 $a_i \leq a_{i - 1} + 1$, 不存在长度为 $a_{i - 1} + 1$ 的 border, 所以只会存在长度小于 $a_{i - 1} + 1$ 的 border. 由于 $a_{i'}$ 的 border 已经求出, 而已知 $[1, a_{i - 1}]$ 和 $[i - a_{i - 1}, i - 1]$ 是匹配的, 所以可以知道 $[1, i - 1]$ 的最长 border 的最长 border 也是相匹配的, 即 $[1, a_{a_{i - 1}}]$ 和 $[i - a_{a_{i - 1}}, i - 1]$ 是匹配的, 只要判断 ${s_2}_{a_{a_{i - 1}} + 1}$ 和 ${s_2}_i$ 是否相等即可

举例

ABAABA              // [1, 6]
ABA___ ___ABA       // a[6] = 3
ABAABAB             // [1, 7]
___A___ != ______B  // s[4] != s[7]
ABA A__ __A         // a_[a[6]] = a[3] = 1
_B_____ = ______B   // s[2] = s[7]
AB_____ _____AB     // a[7] = 2

对于这样求最长 border 的正确性证明, 和 $a_i \leq a_{i - 1} + 1$ 的证明同理, 只要每次 border 末尾字符匹配失败时使枚举的长度 $k = a[k]$ 即可.

接下来是复杂度分析, 由于每次递推时, $a_i$ 最多会比 $a_{i - 1}$ 增加 $1$, 所以对于最坏的情况, 即对于所有 $i$, 有 $a_i = i - 1$, 对于一个每次都匹配失败的 $i$, 需要循环 $i$ 次, 然后使 $a_i = 0$, $i$ 之后的子循环次数再次变成常数. 所以均摊复杂度 $O(m)$

匹配

枚举 $i$ 作为 ${s_2}_1$ 在 $s_1$ 中的对应字符位置, 每次从匹配的字符往后扫, 直到字符不匹配或匹配成功. 这时, 已知 $s_1[i, i + k - 1]$ 和 $s_2[1, k]$ 匹配, 所以 $s_1[i + k - a_k, i + k - 1]$ 和 $s_2[1, a_k]$ 一定匹配, 此时对应 ${s_2}_1$ 的字符是 ${s_1}_{i + k - a_k}$, 即 $i = i + k - a_k$. 而对于 $i' \in (i, i + k - a_k)$, 一定不存在和 $s_2$ 合法的匹配, 下面给出证明

仍是反证法, 对于 $s_1[i, i + k - 1]$ 和 $s_2[1, k]$ 已经匹配, 而 ${s_1}_{i + k} \neq {s_2}_{k + 1}$ 的情况, 假设存在 $i' \in (i, i + k - a_k)$ 使得 $s_1[i', i' + m - 1]$ 和 $s2$ 匹配, 则 $s_1[i', i + k - 1]$ 和 $s_2[1, i + k - i']$ 匹配, 又因为 $i' < i + k - a_k$, 所以 $i + k - i' > a_k$. 这样一来, $s_1[i', i + k - 1]$ 和 $s_2[1, i + k - i']$ 匹配和 ${s_1}_{i + k} \neq {s_2}_{k + 1}$ 矛盾, 假设不成立, 原结论得证

所以每次匹配结束 (失败/成功) 后, 设已经匹配的长度为 $k$, 则直接使 $i = i + k - a_k$, $k = a_k$, 进行下一轮匹配, 保证不遗漏任何一个可行匹配

分析复杂度, 每次 $s_1$ 有一个字符被成功匹配, ${s_1}_i$不会再和 $s_2$ 中任何字符比较第二次. 所以分析 $s_1$ 中字符匹配失败的概率. 发现失败次数和 $k = a_k$ 递归层数有关, 根据上面求 $a$ 数组时的分析, 发现失败次数均摊 $O(1)$, 所以匹配的复杂度 $O(n)$, 整个算法加上预处理的复杂度为 $O(n + m)$

代码

求 $a$ 数组, 枚举 $s_2$ 前缀长度 $i$

unsigned k(1);
for (register unsigned i(2); i <= lb; ++i)  { // Origin_Len
  while ((B[k] != B[i] && k > 1) || k > i) {
    k = a[k - 1] + 1; // 这里 k 相当于如果本次匹配成功得到的 border 长度 
  }
  if(B[k] == B[i]) { // 是匹配成功跳出而不是 a[k] = 0 溢出的 
    a[i] = k;
    ++k;
  }
}

匹配两个字符串, 代码中 $k$ 的含义略有不同, 结合注释理解, 某些注释英语水平感人, 英文注释是出于打代码时害怕各种编辑器对中文的编码兼容性问题

k = 1;
for (register unsigned i(1); i + lb <= la + 1;) {  // Origin_Address
  while (A[i + k - 1] == B[k] && k <= lb) {
    ++k;  // 代码中 k 是待匹配的字符在 s_2 中的位置, 所以比实际匹配的长度多 1 
  }
  if(k == lb + 1) { // 匹配成功 
    printf("%u\n", i); 
  }
  if(a[k - 1] == 0) { // k = a[k] 的递归边界 
    ++i;
    k = 1;
    continue;
  }
  --k;            // k 是匹配失败的字符在 s_2 中的位置, 所以实际有 k - 1 长度的子串匹配成功 
  i += k - a[k];  // Substring of Len(k - 1) has already paired, so the next time, start with the border of the (k - 1) length substring
  k = a[k] + 1;   // 为什么我要写英文啊, 这是对 i 和 k 的同时移动, k = a[k] + 1 意思是在新起点已经匹配的 a[k] 长度的前缀之后的第一个字符开始比较 
}

模板 Luogu P3375