KMP算法

任何优秀的算法都是简约而美丽的。KMP更是如此。

下面这些定义是十分重要的，功欲善其事，必先利其器。

1. 基本定义（Basic Definitions）

设 $A$ 为一个字符集，并且 $x=x_0…x_{k-1}$，$k$ 为自然数，$x$ 是长度为 $k$ 的在 $A$

$x$ 的前缀(prefix)为一个字串$u$, 其中：
$u = x_0x_1…x_{b-1}, b\in\{0,1, …,k\}$
$x$ 的后缀(suffix)为一个字串$u$, 其中：
$u = x_{k-b}x_{k-b+1}…x_{k-1}, b\in\{0,1, …,k\}$
如果$u \neq x (即b < k)$, 则 $x$ 的一个前缀或者后缀 $u$ 被称为真前缀(proper prefix)或真后缀(proper suffix)。

设 $x$ 的一个边框(border)(这个概念相当重要，往后读读就会明白)是一个子串 $r$。为了防止丢失语义，后面 border 不再翻译为中文。

其中：
$r = x_0x_1…x_{b-1} 且 r=x_{k-b}x_{k-b+1}…x_{k-1}, b∈\{0,1, …,k-1\},k=|x|$

border是 $x$ 的一个真子串，这个真子串由真前缀和真后缀构成，且真前缀和真后缀相等。我们称长度 $b$ 为 border 的宽度(width)（说是厚度也许更确切，更能表达意思），如果某个 border 的宽度是所有 border 中最大的，则称该 border 为最宽 border (widest border)。

可以看到 border 具有一个很好的性质：即左边界=右边界。

1.1 示例

• 例1：设$x = abacab$.则$x$的真前缀分别为$\{\varepsilon, a, ab, aba, abac, abaca\}$真后缀分别为$\{\varepsilon, b, ab, cab, acab, bacab, x\}$，因此$x$具有两个border，分别是$\varepsilon 和 ab$。

其中 border $\varepsilon$ 表示宽度为0的串，border $ab$ 的宽度为2，最宽 border 很明显为$ab$.

把这个最宽 border 加红一下：$x =\color{red}{ab}\color{black}{ac}\color{red}{ab}$，可以看到，这个红色部分非常像一个边框，这也是 border 的含义。

对于任意字符串 $x\in A$（$A$是一个字符集），其中空串 $\varepsilon$ 总为 $x$ 的一个 border。空串$\varepsilon$本身没有 border。
KMP算法中的位移量(shift distance)将会用到字符串中 border 的概念。

• 例2：模式串与目标创匹配过程。

i	0	1	2	3	4	5	6	7	8	9
t	$a$	$b$	$c$	$a$	$b$	$c$	$a$	$b$	$d$
p	$\color{blue}a$	$\color{blue}b$	$\color{green}c$	$\color{blue}a$	$\color{blue}b$	$\color{red}d$
p				$\color{blue}a$	$\color{blue}b$	$c$	$\color{blue}a$	$\color{blue}b$	$d$

位置 $0,…,4$ 的字符已经完全匹配，但是在位置5，$c$ 和 $d$

其中位移量取决于已匹配的字符串（如上图中 $abcab$ 部分）的最宽 border (上图的蓝色部分)，在这个例子中，已经匹配的 $abcab$ 的串长 $j=5$ ，其中最宽 border $ab$ 的宽度为 $b=2$ ，于是位移量为 $j-b = 5-2=3$.

这样做的原因是 border 有左右两个部分，如上面的$x =\color{red}{ab}\color{black}{ac}\color{red}{ab}$，我们知道左右两个部分是完全一样的。如果 $p_0p_1...p_{j-1}$ 部分已经完全匹配，但是在 $j$ 处失配($p_j \neq t_i$)。此时假设我们已经知道 $p_0p_1...p_{j-1}$

KMP 的核心思想：

• 在预处理阶段，先求出模式串的每个前缀的最宽 border 的宽度。
• 在搜索阶段，位移量可以根据已经匹配上的前缀计算得出。

2. 预处理(Preprocessing)

2.1 next-widest border

定理（Theorem）：设串 $r, s$ 都是串 $x$ 的 border，其中 $|r| < |s|$，则串 $r$ 是串 $s$

证明：图1中的串 $x$ 包含了两个 border $r$ 和 $s$.由于 $r$ 是 $x$ 的前缀，同时它也是 $s$ 的真前缀，而且 $r$也是 $x$ 的后缀，$r$也是 $s$ 的真后缀，又因为 $r$ 的长度小于 $s$，因此 $r$ 是 $s$

图1 border 的 border

• 例3： 串$abacaba$有两个非空 border，一个是$a$,标红后为$\color{red}{a}\color{black}{bacab}\color{red}a$，还有一个是$aba$，标记成绿$\color{green}{aba}\color{black}{c}\color{green}{aba}$，很明显可以看到$a$也是$\color{red}{a}\color{black}{b}\color{red}a$

这个性质非常有用，后面可以看到。

如果串 $s$ 是 $x$ 的最宽 border，则 $x$ 的下一最宽 border (next-widest border)为 $s$ 的最宽 border $r$.

说的直白点，下一个最宽 border = ($x$的最宽 border)的最宽 border，用编程语言描述话就是这样：

// 假设 border 函数可以求取最宽 border
s = border(x);
// 称 r 为 x 的 next-widest border
r = border(s);
// 也有结论：
r = border(border(x));

2.2 border 延拓 (extend)

定义：设 $x$ 是一个字符串，且 $a$ 是 $A$ 上的一个字符，如果 $ra$ 是 $xa$ 的一个 border，则称 $x$ 的 border $r$ 可通过字符 $a$

图2 border 延拓

图2中，如果 $x_j=a$，则 $x$ 的宽为 $j$ 的 border 可通过字符 $a$ 延拓为 $ra$，$ra$是 $xa$的 border。

• 例4：$s=cbobcbo$,$s$的一个子串$x=cbobcb$可以通过字符$o$延拓为$s$, 已知$x$的 border 是$cb$，border 延拓后$cbo$是$s$

2.3 模式串预处理

在预处理阶段，构造一个长度为 $m+1$ 的数组 $b$ (m 是模式串 p 的长度)，数组的每一项 $b[i]$ 为模式串 $p=p_0p_1\cdots p_{m-1}$ 的长度为 $i$ 的前缀$(p_0p_1\cdots p_{i-1})$的最宽 border 的宽度 $(i=0,…,m)$。由于长度为 0 的前缀 $\varepsilon$ 没有 border，我们规定$b[0] = -1$。

图3 模式串 p 的长度为 i 的前缀，它的最宽 border 宽度是 b[i]

---

那么如果求取模式串长度为 i 的前缀的最宽 border 的宽度呢？

可以使用归纳法。

假设 $b[0..i]$ 的值已知，则 $b[i+1]$ 的值可以通过检测串 $p_0…p_{i-1}$ 的 border $r$ 否可以通过字符 $p_i$ 延拓来计算。其中 $r = border(p_0…p_{i-1})$。

在图 3 中，判断是否有 $p_i = p_{b[i]}$，注意灰色部分是 $p_0…p_{i-1}$ 的 border，其宽度就是 $b[i]$。如果 $p_i = p_{b[i]}$，可以得到 $b[i+1]=b[i]+1$。如果$p_i \neq p_{b[i]}$，则继续看 next-widest border 是否可以延拓。

可以利用 $b[i],b[b[i]],b[b[b[i]]]…$ 的降序，可以获得 $p_0…p_{i-1}$

预处理算法包括了一个含变量 $j$ 的循环，用来遍历这些值，即$b[j],b[b[j]],b[b[b[j]]]…$

如果 $p_j=p_i$，则宽为 $j$ 的 border 可以通过字符 $p_i$延拓；否则，通过把 $j$ 设为 $b[j]$，即去查找next-widest border，看是否可以延拓，可以那就可以去设定 $b[i+1]$ 的值了，如果不可以，继续查找，直到再也找不到 next-widest border 为止，即 $j = -1$的时候。

每次出现 $j$++ 后，$j$ 的值就是$p_0…p_i$的最宽 border 的宽度，因为找到了一个字符 $p_j=p_i$ 可以把 border $p_0p_1…p_{j-1}$ 延拓为新的 border $p_0p_1…p_{j}$，因此 $p_0…p_i$ 的最宽 border 的宽度就是串 $p_0p_1…p_{j-1}$ 的宽度加1。然后把 $b[i+1]$ 的值设置为 $j$ (也就是 $i$++ 后设置 $b[i]$

void kmpPreprocess()
{ 
    //i: 当前指针。j: 当前 border 的宽度。
    int i = 0, j = -1;
    b[i] = j; //初始化b[0]
    while (i < m)
    {
        //查找下一最宽 border，直到可以延拓
        while (j >= 0 && p[i] != p[j]) j = b[j];// border 宽度大于等于0且无法延拓
        // 进行延拓。
        i++; j++;
        b[i] = j;
    }
}

• 例5：对于模式串$p=ababaa$，数组$b$中保存的 borders 宽度分别如下。例如，长度为$5$的前缀$ababa$有一个宽度为3的 border，因此$b[5]=3$.

j	0	1	2	3	4	5	6
p[j]	a	b	a	b	a	a
b[j]	-1	0	0	1	2	3	1

3. 搜索算法(Searching algorithm)

假设我们把上面算法的模式串 $p$（长度为$m$）改成 $pt$ ($pt$ 是模式串 $p$ 和目标串 $t$ 的连接，见图4)，上面的预处理算法理所当然也适用于计算串 $pt$ 的 border 的宽度，如果把串 $p$ 看成 $pt$ 的某个长度为 $i$ 的前缀 $x$ 的一个 border，只要找到了这样的前缀 $x$，那就等于找到了匹配串的位置，即 $i-m$。

串 $pt$ 的某个前缀 $x$ 正好有一个宽度为 $m$ 的 border，那就说明搜索成功了，这个时候匹配位置为 $i-m$，接着继续匹配下一个位置（如图4）。

图4 pt 的一个前缀 x 的宽度为 m 的 border 搜索算法如下：

void kmpSearch()
{
    //i: 当前指针 j: 当前 border 的宽度
    int i = 0, j = 0;
    while (i < n)
    {    
        // 当前位置无法延拓就继续搜索下一最宽 border，直到可以延拓。
        while (j >= 0 && t[i] != p[j]) j = b[j];
        i++; j++;   
        //如果 border 的宽度正好为 m，说明匹配到模式串了
        if (j == m)
        {
            //上报匹配结果
            report(i – j);
            
            //将j降到下一最宽 border，然后继续执行下一次匹配。实际上，这行代码也可略去不写。
            //因为一下次执行到while(j>=0&&t[i]!=p[j])j=b[j];也会因为无法延拓而执行循环体。
            //此时的p[j]肯定等于字符'\0'
            j = b[j];
        }
    }
}

当内循环在 $j$ 处无法延拓时，则检查下一最宽 border 是否可以延拓，即检查模式串的长度为 $j$ 的最宽 border 是否可以延拓（如图5）。如果仍无法延拓，则继续检查下一最宽 border，直至下一最宽 border 为空（即$j = -1$时），或者可以延拓为止。

图5 在 j 处失配（无法延拓）后模式串的移动，即看是否可以延拓下一最宽 border

---

如果所有的 $m$ 个字符都可以匹配上，这时候$j=m$，函数 $report$

下面给出一个完整的代码：

#include "string.h"

char t[] = "ababbababacabacababacacbacababacababaa";
char p[] = "ababac";
const int n = strlen(t);
const int m = strlen(p);
int b[7] = {0};

void KmpPreprocess()
{
  int i = 0, j = -1;
  b[i] = j;
  while (i < m)
  {
    while (j >= 0 && p[i] != p[j]) j = b[j];
    i++; j++;
    b[i] = j;
  }
}
void report(int nIndex)
{
  printf("%d ", nIndex);
}
void KmpSearch()
{
  int i = 0, j = 0;
  while (i < n)
  {
    while (j >= 0 && t[i] != p[j]) j = b[j];
    i++; j++;
    if (j == m)
    {
      report(i - j);
      j = b[j];
    }
  }
}

int _tmain(int argc, _TCHAR* argv[])
{
  KmpPreprocess();
  KmpSearch();
  getchar();
  return 0;
}

参考文献：​​http://www.inf.fh-flensburg.de/lang/algorithmen/pattern/kmpen.htm​​