Boyer–Moore 算法

KMP 算法将前缀匹配的信息用到了极致，

而 BM 算法背后的基本思想是通过后缀匹配获得比前缀匹配更多的信息来实现更快的字符跳转。

引入

想象一下，如果我们的的模式字符串 $p a t$ ，被放在文本字符串 $s t r i n g$ 的左手起头部，使它们的第一个字符对齐。

\begin{aligned} pat : & EXAMPLE \\ string : & HERE IS A SIMPLE EXAMPLE \dots \\ ⇑ \end{aligned}

在这里做定义，往后不赘述：

$p a t$ 的长度为 $p a t l e n$ ，特别地对于从 0 开始的串来说，规定 $p a t l a s t p o s = p a t l e n - 1$ 为 $p a t$ 串最后一个字符的位置；

$s t r i n g$ 的长度 $s t r i n g l e n$ ， $s t r i n g l a s t p o s = s t r i n g l e n - 1$ 。

假如我们知道了 $s t r i n g$ 的第 $p a t l e n$ 个字符 $c h a r$ （与 $p a t$ 的最后一个字符对齐）考虑我们能得到什么信息：

观察 1

如果我们知道 $c h a r$ 这个字符不在 $p a t$ 中，我们就不用考虑 $p a t$ 从 $s t r i n g$ 的第 $1$ 个、第 $2$ 个……第 $p a t l e n$ 个字符起出现的情况，，而可以直接将 $p a t$ 向下滑动 $p a t l e n$ 个字符。

观察 2

更一般地，如果出现在 $p a t$ 最末尾（也就是最右边）的那一个 $c h a r$ 字符的位置是离末尾端差了 $d e l t a_{1}$ 个字符，

那么就可以不用匹配，直接将 $p a t$ 向后滑动 $d e l t a_{1}$ 个字符：如果滑动距离少于 $d e l t a_{1}$ ，那么仅就 $c h a r$ 这个字符就无法被匹配，当然模式字符串 $p a t$ 也就不会被匹配。

因此除非 $c h a r$ 字符可以和 $p a t$ 末尾的那个字符匹配，否则 $s t r i n g$ 要跳过 $d e l t a_{1}$ 个字符（相当于 $p a t$ 向后滑动了 $d e l t a_{1}$ 个字符）。并且我们可以得到一个计算 $d e l t a_{1}$ 的函数 $d e l t a_{1} (c h a r)$ ：

\begin{array}{ll} int d e l t a 1 (char c h a r) \\ if char不在pat中 || char是pat上最后一个字符 \\ return p a t l e n \\ else \\ return p a t l a s t p o s - i // i为出现在pat最末尾的那一个char出现的位置，即pat[i]=char \end{array}

需要注意，显然这个表只需计算到 $p a t l a s t p o s - 1$ 的位置。

现在假设 $c h a r$ 和 $p a t$ 最后一个字符匹配到了，那我们就看看 $c h a r$ 前一个字符和 $p a t$ 的倒数第二个字符是否匹配：

如果是，就继续回退直到整个模式串 $p a t$ 完成匹配（这时我们就在 $s t r i n g$ 上成功得到了一个 $p a t$ 的匹配）；

或者，我们也可能会在匹配完 $p a t$ 的倒数第 $m$ 个字符后，在倒数第 $m + 1$ 个字符上失配，这时我们就希望把 $p a t$ 向后滑动到下一个可能会实现匹配的位置，当然我们希望滑动得越远越好。

观察 3(a)

在 观察 2 中提到，当匹配完 $p a t$ 的倒数 $m$ 个字符后，如果在倒数第 $m + 1$ 个字符失配，为了使得 $s t r i n g$ 中的失配字符与 $p a t$ 上对应字符对齐，

需要把 $p a t$ 向后滑动 $k$ 个字符，也就是说我们应该把注意力看向之后的 $k + m$ 个字符（也就是看向 $p a t$ 滑动 k 之后，末段与 $s t r i n g$ 对齐的那个字符）。

而 $k = d e l t a_{1} - m$ ，

所以我们的注意力应该沿着 $s t r i n g$ 向后跳 $d e l t a_{1} - m + m = d e l t a_{1}$ 个字符。

然而，我们有机会跳过更多的字符，请继续看下去。

观察 3(b)

如果我们知道 $s t r i n g$ 接下来的 $m$ 个字符和 $p a t$ 的最后 $m$ 个字符匹配，假设这个子串为 $s u b p a t$ ，

我们还知道在 $s t r i n g$ 失配字符 $c h a r$ 后面是与 $s u b p a t$ 相匹配的子串，而假如 $p a t$ 对应失配字符前面存在 $s u b p a t$ ，我们可以将 $p a t$ 向下滑动一段距离，

使得失配字符 $c h a r$ 在 $p a t$ 上对应的字符前面出现的 $s u b p a t$ （合理重现，plausible reoccurrence，以下也简称 pr）与 $s t r i n g$ 的 $s u b p a t$ 对齐。如果 $p a t$ 上有多个 $s u b p a t$ ，按照从右到左的后缀匹配顺序，取第一个（rightmost plausible reoccurrence，以下也简称 rpr）。

假设此时 $p a t$ 向下滑动的 $k$ 个字符（也即 $p a t$ 末尾端的 $s u b p a t$ 与其最右边的合理重现的距离），这样我们的注意力应该沿着 $s t r i n g$ 向后滑动 $k + m$ 个字符，这段距离我们称之为 $d e l t a_{2} (j)$ ：

假定 $r p r (j)$ 为 $s u b p a t = p a t [j + 1 \dots p a t l a s t p o s]$ 在 $p a t [j]$ 上失配时的最右边合理重现的位置， $r p r (j) < j$ （这里只给出简单定义，在下文的算法设计章节里会有更精确的讨论），那么显然 $k = j - r p r (j), m = p a t l a s t p o s - j$ 。

所以有：

\begin{array}{ll} int d e l t a 2 (int j) // j为失配字符在pat上对应字符的位置 \\ return p a t l a s t p o s - r p r (j) \end{array}

于是我们在失配时，可以把把 $s t r i n g$ 上的注意力往后跳过 $max (d e l t a_{1}, d e l t a_{2})$ 个字符

过程

箭头指向失配字符 $c h a r$ ：

\begin{aligned} pat : & AT-THAT \\ string : \dots & WHICH-FINALLY-HALTS.--AT-THAT-POINT \dots \\ ⇑ \end{aligned}

$F$ 没有出现 $p a t$ 中，根据 观察 1， $p a t$ 直接向下移动 $p a t l e n$ 个字符，也就是 7 个字符：

\begin{aligned} pat : & AT-THAT \\ string : \dots & WHICH-FINALLY-HALTS.--AT-THAT-POINT \dots \\ ⇑ \end{aligned}

根据 观察 2，我们需要将 $p a t$ 向下移动 4 个字符使得短横线字符对齐：

\begin{aligned} pat : & AT-THAT \\ string : \dots & WHICH-FINALLY-HALTS.--AT-THAT-POINT \dots \\ ⇑ \end{aligned}

现在char: $T$ 匹配了，把 $s t r i n g$ 上的指针左移一步继续匹配：

\begin{aligned} pat : & AT-THAT \\ string : \dots & WHICH-FINALLY-HALTS.--AT-THAT-POINT \dots \\ ⇑ \end{aligned}

根据 观察 3(a)， $L$ 失配，因为 $L$ 不在 $p a t$ 中，所以 $p a t$ 向下移动 $k = d e l t a_{1} - m = 7 - 1 = 6$ 个字符，而 $s t r i n g$ 上指针向下移动 $d e l t a_{1} = 7$ 个字符：

\begin{aligned} pat : & AT-THAT \\ string : \dots & WHICH-FINALLY-HALTS.--AT-THAT-POINT \dots \\ ⇑ \end{aligned}

这时 $c h a r$ 又一次匹配到了 $p a t$ 的最后一个字符 $T$ ， $s t r i n g$ 上的指针向左匹配，匹配到了 $A$ ，继续向左匹配，发现在字符 $-$ 失配：

\begin{aligned} pat : & AT-THAT \\ string : \dots & WHICH-FINALLY-HALTS.--AT-THAT-POINT \dots \\ ⇑ \end{aligned}

显然直观上看，此时根据 观察 3(b)，将 $p a t$ 向下移动 $k = 5$ 个字符，使得后缀 $AT$ 对齐，这种滑动可以获得 $s t r i n g$ 指针最大的滑动距离，此时 $d e l t a_{2} = k + p a t l a s t p o s - j = 5 + 6 - 4 = 7$ ，即 $s t r i n g$ 上指针向下滑动 7 个字符。

而从形式化逻辑看，此时， $d e l t a_{1} = 7 - 1 - 2 = 4, d e l t a_{2} = 7, max (d e l t a_{1}, d e l t a_{2}) = 7$ ，这样从形式逻辑上支持了进行 观察 3(b) 的跳转：

\begin{aligned} pat : & AT-THAT \\ string : \dots & WHICH-FINALLY-HALTS.--AT-THAT-POINT \dots \\ ⇑ \end{aligned}

现在我们发现了 $p a t$ 上每一个字符都和 $s t r i n g$ 上对应的字符相等，我们在 $s t r i n g$ 上找到了一个 $p a t$ 的匹配。而只花费了 14 次对 $s t r i n g$ 的引用，其中 7 次是完成一个成功的匹配所必需的比较次数（ $p a t l e n = 7$ ），另外 7 次让我们跳过了 22 个字符。

算法设计

最初的匹配算法

解释

现在看这样一个利用 $d e l t a_{1}$ 和 $d e l t a_{2}$ 进行字符串匹配的算法：

\begin{array}{ll} i \leftarrow p a t l a s t p o s . \\ j \leftarrow p a t l a s t p o s . \\ loop \\ if j < 0 \\ return i + 1 \\ if s t r i n g [i] = p a t [j] \\ j \leftarrow j - 1 \\ i \leftarrow i - 1 \\ continue \\ i \leftarrow i + m a x (d e l t a_{1} (s t r i n g [i]), d e l t a_{2} (j)) \\ if i > s t r i n g l a s t p o s \\ return f a l s e \\ j \leftarrow p a t l a s t p o s \end{array}

如果上面的算法 $return f a l s e$ ，表明 $p a t$ 不在 $s t r i n g$ 中；如果返回一个数字，表示 $p a t$ 在 $s t r i n g$ 左起第一次出现的位置。

然后让我们更精细地描述下计算 $d e l t a_{2}$ ，所依靠的 $r p r (j)$ 函数。

根据前文定义， $r p r (j)$ 表示在 $p a t (j)$ 失配时，子串 $s u b p a t = p a t [j + 1 \dots p a t l a s t p o s]$ 在 $p a t [j]$ 最右边合理重现的位置。

也就是说需要找到一个最好的 $k$ , 使得 $p a t [k \dots k + p a t l a s t p o s - j - 1] = p a t [j + 1 \dots p a t l a s t p o s]$ ，另外要考虑两种特殊情况：

当 $k < 0$ 时，相当于在 $p a t$ 前面补充了一段虚拟的前缀，实际上也符合 $d e l t a_{2}$ 跳转的原理。
当 $k > 0$ 时，如果 $p a t [k - 1] = p a t [j]$ ，则这个 $p a t [k \dots k + p a t l a s t p o s - j - 1]$ 不能作为 $s u b p a t$ 的合理重现。原因是 $p a t [j]$ 本身是失配字符，所以 $p a t$ 向下滑动 $k$ 个字符后，在后缀匹配过程中仍然会在 $p a t [k - 1]$ 处失配。

还要注意两个限制条件：

$k < j$ 。因为当 $k = j$ 时，有 $p a t [k] = p a t [j]$ ，在 $p a t [j]$ 上失配的字符也会在 $p a t [k]$ 上失配。
考虑到 $d e l t a_{2} (p a t l a s t p o s) = 0$ ，所以规定 $r p r (p a t l a s t p o s) = p a t l a s t p o s$ 。

过程

由于理解 $r p r (j)$ 是实现 BoyerMoore 算法的核心，所以我们使用如下两个例子进行详细说明：

\begin{aligned} j : & 0 1 2 3 4 5 6 7 8 \\ pat : & A B C X X X A B C \\ rpr(j) : & 5 4 3 2 1 0 2 1 8 \\ sgn : & - - - - - - - - + \end{aligned}

对于 $r p r (0)$ ， $s u b p a t$ 为 $BCXXXABC$ ，在 $p a t [0]$ 之前的最右边合理重现只能是 $[(BCXXX)ABC]XXXABC$ ，也就是最右边合理重现位置为 -5，即 $r p r (j) = - 5$ ；

对于 $r p r (1)$ ， $s u b p a t$ 为 $CXXXABC$ ，在 $p a t [1]$ 之前的最右边的合理重现是 $[(CXXX)ABC]XXXABC$ ，所以 $r p r (j) = - 4$ ；

对于 $r p r (2)$ ， $s u b p a t$ 为 $XXXABC$ ，在 $p a t [2]$ 之前的最右边的合理重现是 $[(XXX)ABC]XXXABC$ ，所以 $r p r (j) = - 3$ ；

对于 $r p r (3)$ ， $s u b p a t$ 为 $XXABC$ ，在 $p a t [3]$ 之前的最右边的合理重现是 $[(XX)ABC]XXXABC$ ，所以 $r p r (j) = - 2$ ；

对于 $r p r (4)$ ， $s u b p a t$ 为 $XABC$ ，在 $p a t [4]$ 之前的最右边的合理重现是 $[(X)ABC]XXXABC$ ，所以 $r p r (j) = - 1$ ；

对于 $r p r (5)$ ， $s u b p a t$ 为 $ABC$ ，在 $p a t [5]$ 之前的最右边的合理重现是 $[ABC]XXXABC$ ，所以 $r p r (j) = 0$ ；

对于 $r p r (6)$ ， $s u b p a t$ 为 $BC$ ，又因为 $s t r i n g [0] = s t r i n g [6]$ ，即 $s t r i n g [0]$ 等于失配字符 $s t r i n g [6]$ ，所以 $s t r i n g [0 \dots 2]$ 并不是符合条件的 $s u b p a t$ 的合理重现，所以在最右边的合理重现是 $[(BC)]ABCXXXABC$ ，所以 $r p r (j) = - 2$ ；

对于 $r p r (7)$ ， $s u b p a t$ 为 $C$ ，同理又因为 $s t r i n g [7] = s t r i n g [1]$ ，所以 $s t r i n g [1 \dots 2]$ 并不是符合条件的 $s u b p a t$ 的合理重现，在最右边的合理重现是 $[(C)]ABCXXXABC$ ，所以 $r p r (j) = - 1$ ；

对于 $r p r (8)$ ，根据 $d e l t a_{2}$ 定义， $r p r (p a t l a s t p o s) = p a t l a s t p o s$ ，得到 $r p r (8) = 8$ 。

现在再看一下另一个例子：

\begin{aligned} j : & 0 1 2 3 4 5 6 7 8 \\ pat : & A B Y X C D E Y X \\ rpr(j) : & 8 7 6 5 4 3 2 1 8 \\ sgn : & - - - - - - + - + \end{aligned}

对于 $r p r (0)$ ， $s u b p a t$ 为 $BYXCDEYX$ ，在 $p a t [0]$ 之前的最右边合理重现只能是 $[(BYXCDEYX)]ABYXCDEYX$ ，也就是最右边合理重现位置为 -8，即 $r p r (j) = - 8$ ；

对于 $r p r (1)$ ， $s u b p a t$ 为 $YXCDEYX$ ，在 $p a t [1]$ 之前的最右边合理重现只能是 $[(YXCDEYX)]ABYXCDEYX$ ， $r p r (j) = - 7$ ；

对于 $r p r (2)$ ， $s u b p a t$ 为 $XCDEYX$ ，在 $p a t [2]$ 之前的最右边合理重现只能是 $[(XCDEYX)]ABYXCDEYX$ ， $r p r (j) = - 6$ ；

对于 $r p r (3)$ ， $s u b p a t$ 为 $CDEYX$ ，在 $p a t [3]$ 之前的最右边合理重现只能是 $[(CDEYX)]ABYXCDEYX$ ， $r p r (j) = - 5$ ；

对于 $r p r (4)$ ， $s u b p a t$ 为 $DEYX$ ，在 $p a t [4]$ 之前的最右边合理重现只能是 $[(DEYX)]ABYXCDEYX$ ， $r p r (j) = - 4$ ；

对于 $r p r (5)$ ， $s u b p a t$ 为 $EYX$ ，在 $p a t [5]$ 之前的最右边合理重现只能是 $[(EYX)]ABYXCDEYX$ ， $r p r (j) = - 3$ ；

对于 $r p r (6)$ ， $s u b p a t$ 为 $YX$ ，因为 $s t r i n g [2 \dots 3] = s t r i n g [7 \dots 8]$ 并且有 $s t r i n g [6] \neq s t r i n g [1]$ ，所以在 $p a t [6]$ 之前的最右边的合理重现是 $AB[YX]CDEYX$ ， $r p r (j) = 2$ ；

对于 $r p r (7)$ ， $s u b p a t$ 为 $X$ ，虽然 $s t r i n g [3] = s t r i n g [8]$ 但是因为 $s t r i n g [2] = s t r i n g [7]$ ，所以在 $p a t [7]$ 之前的最右边的合理重现是 $[X]ABYXCDEYX$ ， $r p r (j) = - 1$ ;

对于 $r p r (8)$ ，根据 $d e l t a_{2}$ 定义， $r p r (p a t l a s t p o s) = p a t l a s t p o s$ ，得到 $r p r (8) = 8$ 。

对匹配算法的一个改进

最后，实践过程中考虑到搜索过程中估计有 80% 的时间用在了 观察 1 的跳转上，也就是 $s t r i n g [i]$ 和 $p a t [p a t l a s t p o s]$ 不匹配，然后跳跃整个 $p a t l e n$ 进行下一次匹配的过程。

于是，可以为此进行特别的优化：

我们定义一个 $d e l t a 0$ ：

\begin{array}{ll} int d e l t a 0 (char c h a r) \\ if c h a r = p a t [p a t l a s t p o s] \\ return l a r g e // large为一个整数，需要满足large>stringlastpos+patlen \\ return d e l t a 1 (c h a r) \end{array}

用 $d e l t a 0$ 代替 $d e l t a_{1}$ ，得到改进后的匹配算法：

\begin{array}{ll} i \leftarrow p a t l a s t p o s \\ loop \\ if i > s t r i n g l a s t p o s \\ return f a l s e \\ while i < s t r i n g l e n \\ i \leftarrow i + d e l t a 0 (s t r i n g (i)) // 除非string[i]和pat末尾字符匹配，否则至多向下滑动patlen \\ if i ⩽ l a r g e //此时表示string上没有一个字符和pat末尾字符匹配 \\ return f a l s e \\ i \leftarrow i - l a r g e \\ j \leftarrow p a t l a s t p o s . \\ while j ⩾ 0 a n d s t r i n g [i] = p a t [j] \\ j \leftarrow j - 1 \\ i \leftarrow i - 1 \\ if j < 0 \\ return i + 1 \\ i \leftarrow i + m a x (d e l t a_{1} (s t r i n g [i]), d e l t a_{2} (j)) \end{array}

其中 $l a r g e$ 起到多重作用，一是类似后面介绍的 Horspool 算法进行快速的坏字符跳转，二是辅助检测字符串搜索是否完成。

经过改进，比起原算法，在做 观察 1 跳转时不必每次进行 $d e l t a_{2}$ 的多余计算，使得在通常字符集下搜索字符串的性能有了明显的提升。

delta2 构建细节

引入

在 1977 年 10 月的Communications of the ACM上，Boyer、Moor 的论文[^bm]中只描述了 $d e l t a_{2}$ 静态表，

构造 $d e l t a_{2}$ 的具体实现的讨论出现在 1977 年 6 月 Knuth、Morris、Pratt 在SIAM Journal on Computing上正式联合发表的 KMP 算法的论文[^kmp]。

朴素算法

在介绍 Knuth 的 $d e l t a_{2}$ 构建算法之前，根据定义，我们会有一个适用于小规模问题的朴素算法：

对于 [0, patlen) 区间的每一个位置 i，根据 subpat 的长度确定其重现位置的区间，也就是 [-subpatlen, i]；
可能的重现位置按照从右到左进行逐字符比较，寻找符合 $d e l t a_{2}$ 要求的最右边 $s u b p a t$ 的重现位置；
最后别忘了令 $d e l t a_{2} (l a s t p o s) = 0$ 。

实现

use std::cmp::PartialEq;

pub fn build_delta_2_table_naive(p: &[impl PartialEq]) -> Vec<usize> {
    let patlen = p.len();
    let lastpos = patlen - 1;
    let mut delta_2 = vec![];

    for i in 0..patlen {
        let subpatlen = (lastpos - i) as isize;

        if subpatlen == 0 {
            delta_2.push(0);
            break;
        }

        for j in (-subpatlen..(i + 1) as isize).rev() {
            // subpat 匹配
            if (j..j + subpatlen)
            .zip(i + 1..patlen)
            .all(|(rpr_index, subpat_index)| {
                if rpr_index < 0 {
                    return true;
                }

                if p[rpr_index as usize] == p[subpat_index] {
                    return true;
                }

                false
            })
            && (j <= 0 || p[(j - 1) as usize] != p[i])
            {
                delta_2.push((lastpos as isize - j) as usize);
                break;
            }
        }
    }

    delta_2
}

特别地，对 Rust 语言特性进行必要地解释，下不赘述：

usize 和 isize 是和内存指针同字节数的无符号整数和有符号整数，在 32 位机上相当于 u32 和 i32，64 位机上相当于 u64 和 i64。
索引数组、向量、分片时使用 usize 类型的数字（因为在做内存上的随机访问并且下标不能为负值），所以如果需要处理负值要用 isize，而进行索引时又要用 usize，这就看到使用 as 关键字进行二者之间的显式转换。
impl PartialEq 只是用作泛型，可以同时支持 Unicode 编码的 char 和二进制的 u8。

显然，该暴力算法的时间复杂度为 $O (n^{3})$ 。

高效算法

下面我们要介绍的是时间复杂度为 $O (n)$ ，但是需要额外 $O (n)$ 空间复杂度的高效算法。

虽然 1977 年 Knuth 提出了这个构建方法，然而他的原始版本的构建算法存在一个缺陷，实际上对于某些 $p a t$ 产生不出符合定义的 $d e l t a_{2}$ 。

Rytter 在 1980 年SIAM Journal on Computing上发表的文章[^rytter]对此提出了修正，以下是 $d e l t a_{2}$ 的构建算法：

首先考虑到 $d e l t a_{2}$ 的定义比较复杂，我们按照 $s u b p a t$ 的重现位置进行分类，每一类进行单独处理，这是高效实现的关键思路。

按照重现位置由远到近，也就是偏移量由大到小，分成如下几类：

整个 $s u b p a t$ 重现位置完全在 $p a t$ 左边的，比如 $[(EYX)]ABYXCDEYX$ ，此时 $d e l t a_{2} (j) = p a t l a s t p o s \times 2 - j$ ；
$s u b p a t$ 的重现有一部分在 $p a t$ 左边，有一部分是 $p a t$ 头部，比如 $[(XX)ABC]XXXABC$ ，此时 $p a t l a s t p o s < d e l t a_{2} (j) < p a t l a s t p o s \times 2 - j$ ；我们把 $s u b p a t$ 完全在 $p a t$ 头部的的边际情况也归类在这里（当然根据实现也可以归类在下边），比如 $[ABC]XXXABC$ ，此时 $p a t l a s t p o s = d e l t a_{2} (j)$ ；
$s u b p a t$ 的重现完全在 $p a t$ 中，比如 $AB[YX]CDEYX$ ，此时 $d e l t a_{2} (j) < p a t l a s t p o s$ 。

现在来讨论如何高效地计算这三种情况：

第一种情况

这是最简单的情况，只需一次遍历并且可以顺便将 $d e l t a_{2}$ 初始化。

第二种情况

我们观察什么时候会出现 $s u b p a t$ 的重现一部分在 $p a t$ 左边，一部分是 $p a t$ 的头部的情况呢？应该是 $s u b p a t$ 的某个后缀和 $p a t$ 的某个前缀相等，

比如之前的例子：

\begin{aligned} j : & 0 1 2 3 4 5 6 7 8 \\ pat : & A B C X X X A B C \end{aligned}

$d e l t a_{2} (3)$ 的重现 $[(XX)ABC]XXXABC$ ， $s u b p a t$ $XXABC$ 的后缀与 pat 前缀中，有相等的，是 $ABC$ 。

实际上，对第二种和第三种情况的计算的关键都需要前缀函数的计算和和应用。

那么只要 $j$ 取值使得 $s u b p a t$ 包含这个相等的后缀，那么就可以得到第二种情况的 $s u b p a t$ 的重现，对于例子，我们只需要使得 $j ⩽ 5$ ，

而当 $j = 5$ 时，就是 $s u b p a t$ 完全在 $p a t$ 头部的边际情况。

可以计算此时的 $d e l t a_{2} (j)$ ：

设此时这对相等的前后缀长度为 $prefixlen$ ，可知 $s u b p a t l e n = p a t l a s t p o s - j$ ，那么在 $p a t$ 左边的部分长度是 $s u b p a t l e n - prefixlen$ ，

而 $r p r (j) = - (s u b p a t l e n - prefixlen)$ ，所以得到 $d e l t a_{2} (j) = p a t l a s t p o s - r p r (j) = p a t l a s t p o s \times 2 - j - prefixlen$ 。

其后面可能会有多对相等的前缀和后缀，比如：

\begin{aligned} j : & 0 1 2 3 4 5 6 7 8 9 \\ pat : & A B A A B A A B A A \end{aligned}

在 $j \leq 2$ 处有 $ABAABAA$ ， $2 < j \leq 5$ 处有 $ABAA$ ，在 $5

本页面最近更新：2025/9/14 21:22:43，更新历史
发现错误？想一起完善？在 GitHub 上编辑此页！
本页面贡献者：Enter-tainer, minghu6, Tiphereth-A, HeRaNO, alphagocc, c0nstexpr, CCXXXI, Chrogeek, Early0v0, githuu5y5u, iamtwz, ksyx, megakite, r-value, wineee, Xeonacid, ZnPdCo
本页面的全部内容在 CC BY-SA 4.0 和 SATA 协议之条款下提供，附加条款亦可能应用