1. 引言

字串匹配是極為常見的一種模式匹配。簡單地說，就是判斷主串\(T\)中是否出現該模式串\(P\)，即\(P\)為\(T\)的子串。特別地，定義主串為\(T[0 \dots n-1]\)，模式串為\(P[0 \dots p-1]\)，則主串與模式串的長度各為\(n\)與\(p\)。

暴力匹配

暴力匹配方法的思想非常樸素：

1. 依次從主串的首字元開始，與模式串逐一進行匹配；
2. 遇到失配時，則移到主串的第二個字元，將其與模式串首字元比較，逐一進行匹配；
3. 重複上述步驟，直至能匹配上，或剩下主串的長度不足以進行匹配。

下圖給出了暴力匹配的例子，主串T="ababcabcacbab"，模式串P="abcac"

第二次匹配：

第三次匹配：

C程式碼實現：

int brute_force_match(char *t, char *p) {
    int i, j, tem;
    int tlen = strlen(t), plen = strlen(p);
    for(i = 0, j = 0; i <= tlen - plen; i++, j = 0) {
        tem = i;
        while(t[tem] == p[j] & j < plen) {
            tem++;
            j++;
        }
        // matched
        if(j == plen) {
            return i;
        }
    }
    // [p] is not a substring of [t]
    return -1;
}
 

時間複雜度：i在主串移動次數（外層的for迴圈）有\(n-p\)次，在失配時j移動次數最多有\(p-1\)次（最壞情況下）；因此，複雜度為\(O(n*p)\)。

我們仔細觀察暴力匹配方法，發現：失配後下一次匹配，

• 主串的起始位置 = 上一輪匹配的起始位置 + 1；
• 模式串的起始位置 = 首字元P[0]。

如此未能利用已經匹配上的字元的資訊，造成了重複匹配。舉個例子，比如：第一次匹配失敗時，主串、模式串失配位置的字元分別為 a 與 c，下一次匹配時主串、模式串的起始位置分別為T[1]與P[0]；而在模式串中c之前是ab，未有重複字元結構，因此T[1]與P[0]肯定不能匹配上，這樣造成了重複匹配。直觀上，下一次的匹配應從T[2]

2. KMP演算法

KMP思想

根據暴力方法的缺點，而引出KMP演算法的思想。首先，一般化匹配失敗，如下圖所示：

在暴力匹配方法中，下一次匹配開始時，主串指標會回溯到i+1，模式串指標會回退到0。那麼，如果不讓主串指標發生回溯，模式串的指標應回退到哪個位置才能保證正確匹配呢？首先，我們從上圖中可以得到已匹配上的字元：

\[ T[i \dots i+j-1] = P[0 \dots j-1] \]

KMP演算法思想便是利用已經匹配上的字元資訊，使得模式串的指標回退的字元位置能將主串與模式串已經匹配上的字元結構重新對齊。當有重複字元結構時，下一次匹配如下圖所示：

從圖中可以看出，下一次匹配開始時，主串指標在失配位置i+j，模式串指標回退到m+1；模式串的重複字元結構：

\begin{equation}
T[i+j-m-1 \dots i+j-1] = P[j-m-1 \dots j-1] = P[0 \dots m]
\label{eq:overlap}
\end{equation}

且有

\[ T[i+j] \neq P[j] \neq P[m+1] \]

那麼應如何選取\(m\)值呢？假定有滿足式子\eqref{eq:overlap}的兩個值\(m_1 > m_2\)，如下圖所示：

如果選取\(m=m_2\)，則會丟失\(m=m_1\)的這一種字元匹配情況。由數學歸納法容易知道，應取所有滿足式子\eqref{eq:overlap}中最大的\(m\)值。

KMP演算法中每一次的匹配，

• 主串的起始位置 = 上一輪匹配的失配位置；
• 模式串的起始位置 = 重複字元結構的下一位字元（無重複字元結構，則模式串的首字元）

模式串P="abcac"匹配主串T="ababcabcacbab"的KMP過程如下圖：

部分匹配函式

根據上面的討論，我們定義部分匹配函式（Partial Match，在資料結構書[2]稱之為失配函式）：

\[ f(j) = \left\{ {\matrix{ {\max \{ m \} } & P[0\dots m]=P[{j-m}\dots {j}],0\le m < j \cr {-1} & else \cr } } \right. \]

其表示字串\(P[0 \dots j]\)的字首與字尾完全匹配的最大長度，也表示了模式串中重複字元結構資訊。KMP中大名鼎鼎的next[j]函式表示對於模式串失配位置j+1，下一輪匹配時模式串的起始位置（即對齊於主串的失配位置）；則

\[ next[j] = f(j)+1 \]

如何計算部分匹配函式呢？首先來看一個例子，模式串P="ababababca"的部分匹配函式與next函式如下：

模式串的f(j)滿足\(P[0 \dots f(j)]=P[j-f(j) \dots j]\)，在計算f(j+1)分為兩類情況：

• 若\(P[j+1]=P[f(j)+1]\)，則有\(P[0 \dots f(j)+1]=P[j-f(j) \dots j+1]\)，因此f(j+1)=f(j)+1。
• 若\(P[j+1] \neq P[f(j)+1]\)，則要從\(P[0 \dots f(j)]\)中找出滿足P[f(j+1)]=P[j+1]的f(j+1)，從而得到\(P[0 \dots f(j+1)]=P[j+1-f(j+1) \dots j+1]\)

其中，根據f(j)的定義有：

\[ P[j]=P[f(j)]=P[f(f(j))]=\cdots = P[f^k(j)] \]

其中，\(f^k(j)=f(f^{k-1}(j))\)。通過上面的例子可知，函式\(f^k(j)\)是隨著\(k\)遞減的，並最後收斂於-1。此外，P[j]與p[j+1]相鄰；因此若存在P[f(j+1)]=P[j+1]，則必有

\[ f(j+1)=f^k(j)+1 \]

為了求滿足條件的最大的f(j+1)，因\(f^k(j)\)是隨著\(k\)遞減的，故應為滿足上式的最小\(k\)值。

綜上，部分匹配函式的計算公式如下：

\[ f(j) = \left\{ {\matrix{ {f^k(j-1)+1} & \min \limits_{k} P[f^k(j-1)+1]=P[j] \cr {-1} & else \cr } } \right. \]

程式碼實現

部分匹配函式（失配函式）的C實現程式碼：

int *fail(char *p) {
    int len = strlen(p);
    int *f = (int *) malloc(len * sizeof(int));
    f[0] = -1;
    int i, j;
    for(j = 1; j < len; j++) {
        for(i = f[j-1]; ; i = f[i]) {
            if(p[j] == p[i+1]) {
                f[j] = i + 1;
                break;
            }
            else if(i == -1) {
                f[j] = -1;
                break;
            }
        }
    }
    return f;
}

KMP的C實現程式碼：

int kmp(char *t, char *p) {
    int *f = fail(p);
    int i, j;
    for(i = 0, j = 0; i < strlen(t) && j < strlen(p); ) {
        if(t[i] == p[j]) {
            i++;
            j++;
        }
        else if(j == 0)
            i++;
        else
            j = f[j-1] + 1;
    }
    return j == strlen(p) ? i - strlen(p) : -1;
}

時間複雜度：fail函式的複雜度為\(O(p)\)，kmp函式的複雜度為\(O(n)\)，所以整個KMP演算法的複雜度為\(O(n+p)\)。

3. 參考資料