本文將以特殊的方式來讓人們更好地理解kmp演算法，不包括kmp演算法的推導，接下來，我們將從樸素演算法出發。
在這之前，我們先設主串為S，模式串為T，我們要解決的詢問是主串中是否包含模式串(即T是否為S的子串)。
版權宣告：本文為原創文章，轉載請標明出處。

樸素演算法

樸素演算法說白了就是暴力，簡單地講就是先從主串的第一個位置開始逐個對模式串進行匹配，若匹配失敗，則從主串的第二個位置繼續進行匹配，以此類推，直到匹配成功或主串的結尾。
舉個例子1
主串S：aabaaced
模式串T：aac
首先我們會進行這樣的匹配
aabaaced
aac
發現T[0]和S[0]匹配，T[1]和S[1]匹配，而T[2]==c和S[2]==b匹配失敗，接著我們會這樣
aabaaced
  aac
發現T[1]和S[1]匹配，而T[2]==c和S[3]==b匹配失敗，接著
aabaaced
    aac
發現T[2]和S[2]不匹配，繼續
aabaaced
      aac
這次終於成功匹配。
以上所述就是樸素演算法，然而我們再來看一個例子
舉個例子2

主串S：aaaaaaaaaaaaaaaaaaaaab
模式串T：aaaaab
如果這個例子我們還用樸素演算法去匹配，很顯而易見，每次我們都要從頭開始匹配，做法如下
aaaaaaaaaaaaaaaaaaaaab
aaaaab
從T[0]到T[5]，對S[0]和S[5]依次進行匹配，發現末尾(T[5]和S[5])沒有匹配，繼續
aaaaaaaaaaaaaaaaaaaaab
  aaaaab
從T[0]到T[5]，對S[1]和S[6]依次進行匹配，發現末尾(T[5]和S[6])沒有匹配，繼續
……（此處省略大量的中間過程）
aaaaaaaaaaaaaaaaaaaaab
                             aaaaab
終於匹配成功。
如果用kmp演算法，則過程如下：
aaaaaaaaaaaaaaaaaaaaab
aaaaab
從T[0]到T[5]，對S[0]和S[5]依次進行匹配，發現末尾(T[5]和S[5])沒有匹配，繼續
aaaaaaaaaaaaaaaaaaaaab
  aaaaab
直接匹配T[5]和S[6]發現匹配失敗，繼續
……（此處省略大量的中間過程）
aaaaaaaaaaaaaaaaaaaaab
                                  aaaaab
我們發現kmp演算法從第二次匹配開始省略了T[0]到T[4]對S的匹配，因為由kmp演算法我們知道T[0]到T[4]一定已經匹配了，不需要再判斷，那麼kmp演算法是怎麼知道並利用這些資訊的呢，
接下來我們進入正題。

kmp演算法的理解

首先我們從樸素演算法出發，一步一步去引出kmp演算法
主串S：S[1]S[2]S[3]S[4]S[5]S[6]S[7]S[8]S[9]
模式串T：T[1]T[2]T[3]T[4]T[5]T[6]
一開始，我們先用樸素演算法進行匹配，得到
S[1]S[2]S[3]S[4]S[5]S[6]S[7]S[8]S[9]
T[1]T[2]T[3]T[4]T[5]T[6]
這時候，我們假設前四個匹配成功了，然而S[5]與T[5]匹配失敗，即有
T[1]==S[1]
T[2]==S[2]
T[3]==S[3]
T[4]==S[4]
T[5]!=S[5]
按照樸素演算法的做法，我們應該把T串往右移，得到這樣的式子進行匹配
S[1]S[2]S[3]S[4]S[5]S[6]S[7]S[8]S[9]
      T[1]T[2]T[3]T[4]T[5]T[6]
但是這時候我們思考這樣一個問題，將模式串右移一位是否有可能成功匹配？？
顯而易見，這樣匹配成功的充要條件是：
T[1]==S[2]
T[2]==S[3]
T[3]==S[4]
T[4]==S[5]
T[5]==S[6]
T[6]==S[7]
結合上次匹配的結果，我們可以把這次匹配成功的充要條件進行變化：
T[1]==S[2]==T[2]
T[2]==S[3]==T[3]
T[3]==S[4]==T[4]
T[4]==S[5]
T[5]==S[6]
T[6]==S[7]
由此我們可以得出一個上次匹配失敗後將模式串T右移一位能夠匹配成功的充要條件：
T[1]==T[2]
T[2]==T[3]
T[3]==T[4]
T[4]==S[5]
T[5]==S[6]
T[6]==S[7]
進而得到上次匹配失敗後將模式串T右移一位能夠過匹配成功的必要條件：
T[1]==T[2]
T[2]==T[3]
T[3]==T[4]
注意，這個必要條件只和模式串T有關！
接著我們討論將模式串右移兩位是否能匹配成功：
S[1]S[2]S[3]S[4]S[5]S[6]S[7]S[8]S[9]
             T[1]T[2]T[3]T[4]T[5]T[6]
顯而易見，這樣匹配成功的充要條件是：
T[1]==S[3]
T[2]==S[4]
T[3]==S[5]
T[4]==S[6]
T[5]==S[7]
T[6]==S[8]
結合上次匹配的結果，我們可以把這次匹配成功的充要條件進行變化：
T[1]==S[3]==T[3]
T[2]==S[4]==T[4]
T[3]==S[5]
T[4]==S[6]
T[5]==S[7]
T[6]==S[8]
進而得到上次匹配失敗後將模式串T右移兩位能夠過匹配成功的必要條件：
T[1]==T[3]
T[2]==T[4]
注意，這個必要條件只和模式串T有關！
最後我們討論將模式串右移三位是否能匹配成功：
S[1]S[2]S[3]S[4]S[5]S[6]S[7]S[8]S[9]
                   T[1]T[2]T[3]T[4]T[5]T[6]
顯而易見，這樣匹配成功的充要條件是：
T[1]==S[4]
T[2]==S[5]
T[3]==S[6]
T[4]==S[7]
T[5]==S[8]
T[6]==S[9]
結合上次匹配的結果，我們可以把這次匹配成功的充要條件進行變化：
T[1]==S[4]==T[4]
T[2]==S[5]
T[3]==S[6]
T[4]==S[7]
T[5]==S[8]
T[6]==S[9]
進而得到上次匹配失敗後將模式串T右移三位能夠過匹配成功的必要條件：
T[1]==T[4]
上面討論了三種情況，在第一次匹配到T[5]的時候匹配失敗了，將模式串分別右移動一位，右移動兩位，右移動三位
是否有可能成功
我們這裡設Q為T[1]T[2]T[3]T[4]
可以發現：
右移動一位成功的必要條件是T[1]==T[2]，T[2]==T[3]，T[3]==T[4]，即Q的三個字首等於三個字尾(T[1]T[2]T[3]==T[2]T[3]T[4])

右移動兩位成功的必要條件是T[1]==T[3]，T[2]==T[4]，即Q的兩個字首等於兩個字尾！（T[1]T[2]==T[3]T[4])

右移動三位成功的必要條件是T[1]==T[4]，即Q的一個字首等於一個字尾！
注意，這些移動都只和模式串有關！
這時候，我們可以得出一個結論：
上面這個例子，T[5]是匹配失敗的位置，我們把匹配失敗的位置的前面的所有字元看作一個新的串Q，想要知道右移幾位有可能匹配成功，我們需要討論T[5]前面的字元組成的串Q，如果不滿足Q的三個字首等於三個字尾，我們可以直接跳過右移一位的情況，如果不滿足Q的兩個字首等於兩個字尾，我們可以直接跳過右移兩位的情況，等等，而且，如果一旦滿足，我們在右移後，不需要從模式串的頭部開始匹配，因為如果滿足，前面幾個就已經匹配好了。就比如上面這個例子，若滿足：
T[1]==T[2]
T[2]==T[3]
T[3]==T[4]
我們可以得到右移一位有可能匹配成功，而且因為有上次匹配失敗後留下的資訊
T[2]==S[2]
T[3]==S[3]
T[4]==S[4]
我們可以直接得到
T[1]==T[2]==S[2]
T[2]==T[3]==S[3]
T[3]==T[4]==S[4]
所以直接匹配T[4]和S[5]即可，這麼一來，就是固定主串不動，從匹配失敗的位置開始，判斷模式串需要右移幾位，然後從匹配失敗的位置開始匹配即可，上面那個例子就是T[5]與S[5]匹配失敗，由T[1]T[2]T[3]==T[2]T[3]T[4]可知接下來需要模式串右移一位並匹配T[4]和S[5]。

kmp演算法的使用

在實際使用中，我們不可能匹配失敗一次就去判斷失敗字元前面所有字元組成的串的最長相等的字首和字尾，這樣時間複雜度會很高，所以我們需要在匹配之前對模式串進行預處理，對每個字元如果匹配失敗，要右移幾位進行儲存，在匹配中一旦失敗，直接跳到那個位置就可以了，我們用next陣列進行儲存，比如上面的那個例子，T[5]匹配失敗了，這時候就要讓模式串的指標指向next[5]，next[5]是我們在匹配之前就已經預處理過的。
至於如何處理，本文不給予證明，靠下面的幾串程式碼可以實現，讀者自行思考或閱讀書籍或其它文章即可。
獲得next陣列的程式碼如下，T為模式串：

void get_next() {
    next[0] = -1;
    int i = 0, j = -1;
    int len = strlen(T);
    while(i < len) {
        if(j == -1 || T[i] == T[j])
            next[++i] = ++j;
         else
            j = next[j];
    }
}

程式碼很短，其中next[i]代表的是如果在i位置匹配失敗，應該從哪個位置繼續匹配，跟i前面所有字元組成的串Q的字首與字尾有關。注意，這個next陣列是kmp演算法的核心。
接下來給出匹配的過程程式碼：

bool KMP() {
    get_next();
    int len1 = strlen(T);
    int len2 = strlen(S);
    int i = 0, j = 0;           //i指向模式串T，j指向主串S
    while(j < len2) {
        if(T[i] == S[j]) {
            i++;
            j++;
            if(i == len1) {
                return true;
            }
        } else {
            i = next[i];
            if(i == -1) {
                j++;i++;
            }
        }
    }
    return false;
}

kmp演算法的練習建議

理解kmp演算法：poj2752 poj2406 poj1961
常規kmp演算法練習：poj3461 poj2185

如有錯誤或不妥之處，歡迎指正~