1. 引言

前一篇中介紹了字串KMP演算法，其利用失配時已匹配的字元資訊，以確定下一次匹配時模式串的起始位置。本文所要介紹的Boyer-Moore演算法是一種比KMP更快的字串匹配演算法，它到底是怎麼快的呢？且聽下面分解。

不同於KMP在匹配過程中從左至右與主串字元做比較，Boyer-Moore演算法是從模式串的尾字元開始從右至左做比較。下面討論的一些遞推式都與BM演算法的這個特性有關。

思想

首先，我們一般化匹配失敗的情況，設主串\(y\)、模式串\(x\)的失配位置為i+j與i，且主串、模式串的長度各為\(n\)與\(m\)，如下圖：

已匹配上的字元結構：

\[ y[i+j+1 \dots j+m-1] = x[i+1 \dots m-1] \]

失配後下一次匹配時，模式串應如何對齊於主串呢？從上圖中看出，我們可以利用兩方面的資訊：

1. 已經匹配上的字元結構，
2. 主串失配位置的字元

前一篇中的KMP演算法只利用第一條資訊，而Boyer-Moore演算法則是將這兩方面的資訊都利用到了，故模式串的移動更為高效。同時，根據這兩方面資訊（已匹配資訊與失配資訊），Boyer-Moore演算法引申出來兩條移動規則：好字尾移動（good-suffix shift）與壞字元移動（bad-character shift）。

例項

Moore教授在這裡給出BM演算法一個例項，比如主串=HERE IS A SIMPLE EXAMPLE，模式串=EXAMPLE

在第一次匹配中，模式串在尾字元發生失配，而主串的失配字元為S，且S不屬於模式串的字元；因此下一次匹配時模式串指標應向右移動7位（壞字元移動）。第二次匹配如下圖：

第二次匹配也是在模式串尾字元發生失配，但不同的是主串的失配字元為P屬於模式串的字元；因此下一次匹配時模式串的P（從右開始第一次出現）應對齊於主串的失配字元P（壞字元移動）。第三次匹配如下圖：

在第三次匹配中，模式串的字尾MPLE完全匹配上主串，主串的失配字元為I，不屬於模式串的字元；那麼下一次匹配是模式串指標應怎麼移動呢（是壞字元移動，還是好字尾移動？）？BM演算法採取的辦法：移動步數=\(\max\{壞字元移動步數,\ 好字尾移動步數\}\)

第四次匹配的情況與第二次類似，應按壞字元移動，第五次匹配（模式串與主串完全匹配）如下圖：

2. BM演算法詳述

好字尾移動

因已匹配上的字元結構正好為模式串的字尾，故名之為好字尾。好字尾移動一般分為兩種情況：

1. 移動後，模式串有子串能完全匹配上好字尾；
2. 移動後，模式串只有能部分匹配上好字尾的子串

我們用陣列bmGs[i]表示模式串的失配位置為i時好字尾移動的步數。第一類情況如下圖：

第二類情況如下圖：

接下來的問題是應如何計算bmGs[i]呢？我們引入suff函式，其定義如下：

\[ suff[i]=\max \{k:\ x[i-k+1\dots i]=x[m-k\dots m-1\},1\le i < m \]

表示了模式串中末字元為x[i]的子串能匹配模式串字尾的最大長度。其中，suff[i]=m。

• 對於第一類情況，令i+1=m-suff[a]，則x[i+1..m-1]=x[m-suff[a]..m-1]；根據suff函式的定義，有x[m-suff[a]..m-1]=x[a-suff[a]-1..a]；則x[i+1..m-1]=x[a-suff[a]-1..a]，即可得到bmGs[i]=bmGs[m-suff[a]-1]=m-1-a。

• 對於第二類情況，由字元的部分匹配可得x[0..m-1-bmGs[i]]=x[bmGs[i]..m-1]，即suff[m-1-bmGs[i]]=m-bmGs[i]。令m-bmGs[i]=a，有suff[a-1]=a。因為是部分匹配，故bmGs[i] = m-a > i+1，則i < m-a-1。綜上，當i < m-a-1且suff[a-1]=a時，bmGs[i]=m-a。

• 有可能上述兩種情況都沒能被匹配上，則bmGs[i]=m。

綜合上述三類情況，bmGs陣列計算的實現程式碼（參看[2]）：

void preBmGs(char *x, int m, int bmGs[]) {
   int i, j, suff[XSIZE];
 
   suffixes(x, m, suff);
 
   // case 3, default value
   for (i = 0; i < m; ++i)
      bmGs[i] = m;
   j = 0;
   // case 2
   for (i = m - 1; i >= 0; --i)
      if (suff[i] == i + 1)
         for (; j < m - 1 - i; ++j)
            if (bmGs[j] == m)
               bmGs[j] = m - 1 - i;
   // case 1
   for (i = 0; i <= m - 2; ++i)
      bmGs[m - 1 - suff[i]] = m - 1 - i;
}

壞字元移動

壞字元移動是根據主串失配位置的字元y[i+j]而進行的移動。同樣地，我們用陣列bmBc[c]表示主串失配位置字元為c時壞字元移動的步數。壞字元移動一般分為兩種情況：

1. 模式串x[0..i-1]有字元y[i+j]且第一次出現，如下圖：
   

2. 整個模式串都不包含該字串，如下圖：
   

據此，可以將bmBc[c]定義如下：

\[ bmBc[c]=\min \{i: 1\le i < m \ and \ x[m-1-i]=c \} \]

表示距模式串末字元最近的c字元；若c字元未出現在模式串中，則bmBc[c]=m。C實現程式碼：

void preBmBc(char *x, int m, int bmBc[]) {
   int i;
 
   for (i = 0; i < ASIZE; ++i)
      bmBc[i] = m;
   for (i = 0; i < m - 1; ++i)
      bmBc[x[i]] = m - i - 1;
}

suff函式計算

bmGs[i]的計算依賴於suff函式；如何更為高效的計算suff函式成為了接下來需要考慮的問題。符號標記的定義如下：

• i表示當前位置；
• f記錄上一輪匹配的起始位置；
• g記錄上一輪匹配的失配位置。

這裡所說的匹配指的是與模式串字尾的匹配。同樣地，一般化匹配過程，如下圖：

當g < i < f則必有x[i]=x[m-1-(f-i)]=x[m-1-f+i]；

• 若suff[m-1-f+i] < i-g，則suff[i]=suff[m-1-f+i]；
• 否則，suff[i]與suff[m-1-f+i]沒有關係，要根據定義進行計算。

C實現程式碼：

void suffixes(char *x, int m, int *suff) {
   int f, g, i;
 
   suff[m - 1] = m;
   g = m - 1;
   for (i = m - 2; i >= 0; --i) {
      if (i > g && suff[i + m - 1 - f] < i - g)
         suff[i] = suff[i + m - 1 - f];
      else {
         if (i < g)
            g = i;
         f = i;
         while (g >= 0 && x[g] == x[g + m - 1 - f])
            --g;
         suff[i] = f - g;
      }
   }
}

複雜度分析

3. 參考資料