1. 前幾天做了一道題，做錯了，遂良心發現，我覺得你從頭看到尾，差不多可以明白KMP算法的思想
2. 暴力匹配算法
假設現在我們面臨這樣一個問題：有一個文本串S，和一個模式串P，現在要查找P在S中的位置，怎么查找呢？
如果用暴力匹配的思路，並假設現在文本串S匹配到 i 位置，模式串P匹配到 j 位置，則有：
- 如果當前字符匹配成功（即S[i] == P[j]），則i++，j++，繼續匹配下一個字符；
- 如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0。相當於每次匹配失敗時，i 回溯，j 被置為0。
- int ViolentMatch(char* s, char* p)
- {
- int sLen = strlen(s);
- int pLen = strlen(p);
- int i = 0;
- int j = 0;
- while (i < sLen && j < pLen)
- {
- if (s[i] == p[j])
- {
- //①如果當前字符匹配成功（即S[i] == P[j]），則i++，j++
- i++;
- j++;
- }
- else
- {
- //②如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0
- i = i - j + 1;
- j = 0;
- }
- }
- //匹配成功，返回模式串p在文本串s中的位置，否則返回-1
- if (j == pLen)
- return i - j;
- else
- return -1;
- }
舉個例子，如果給定文本串S“BBC ABCDAB ABCDABCDABDE”，和模式串P“ABCDABD”，現在要拿模式串P去跟文本串S匹配，整個過程如下所示：
1. S[0]為B，P[0]為A，不匹配，執行第②條指令：“如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0”，S[1]跟P[0]匹配，相當於模式串要往右移動一位（i=1，j=0）
2. S[1]跟P[0]還是不匹配，繼續執行第②條指令：“如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0”，S[2]跟P[0]匹配（i=2，j=0），從而模式串不斷的向右移動一位（不斷的執行“令i = i - (j - 1)，j = 0”，i從2變到4，j一直為0）
3. 直到S[4]跟P[0]匹配成功（i=4，j=0），此時按照上面的暴力匹配算法的思路，轉而執行第①條指令：“如果當前字符匹配成功（即S[i] == P[j]），則i++，j++”，可得S[i]為S[5]，P[j]為P[1]，即接下來S[5]跟P[1]匹配（i=5，j=1）
4. S[5]跟P[1]匹配成功，繼續執行第①條指令：“如果當前字符匹配成功（即S[i] == P[j]），則i++，j++”，得到S[6]跟P[2]匹配（i=6，j=2），如此進行下去
5. 直到S[10]為空格字符，P[6]為字符D（i=10，j=6），因為不匹配，重新執行第②條指令：“如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0”，相當於S[5]跟P[0]匹配（i=5，j=0）
6. 至此，我們可以看到，如果按照暴力匹配算法的思路，盡管之前文本串和模式串已經分別匹配到了S[9]、P[5]，但因為S[10]跟P[6]不匹配，所以文本串回溯到S[5]，模式串回溯到P[0]，從而讓S[5]跟P[0]匹配。
而S[5]肯定跟P[0]失配。為什么呢？因為在之前第4步匹配中，我們已經得知S[5] = P[1] = B，而P[0] = A，即P[1] != P[0]，故S[5]必定不等於P[0]，所以回溯過去必然會導致失配。那有沒有一種算法，讓i 不往回退，只需要移動j 即可呢？
答案是肯定的。這種算法就是本文的主旨KMP算法，它利用之前已經部分匹配這個有效信息，保持i 不回溯，通過修改j 的位置，讓模式串盡量地移動到有效的位置。
3. KMP算法
3.1 定義
- 假設現在文本串S匹配到 i 位置，模式串P匹配到 j 位置
- 如果j = -1，或者當前字符匹配成功（即S[i] == P[j]），都令i++，j++，繼續匹配下一個字符；
- 如果j != -1，且當前字符匹配失敗（即S[i] != P[j]），則令 i 不變，j = next[j]。此舉意味着失配時，模式串P相對於文本串S向右移動了j - next [j] 位。
- 換言之，當匹配失敗時，模式串向右移動的位數為：失配字符所在位置 - 失配字符對應的next 值（next 數組的求解會在下文的3.3.3節中詳細闡述），即移動的實際位數為：j - next[j]，且此值大於等於1。
- int KmpSearch(char* s, char* p)
- {
- int i = 0;
- int j = 0;
- int sLen = strlen(s);
- int pLen = strlen(p);
- while (i < sLen && j < pLen)
- {
- //①如果j = -1，或者當前字符匹配成功（即S[i] == P[j]），都令i++，j++
- if (j == -1 || s[i] == p[j])
- {
- i++;
- j++;
- }
- else
- {
- //②如果j != -1，且當前字符匹配失敗（即S[i] != P[j]），則令 i 不變，j = next[j]
- //next[j]即為j所對應的next值
- j = next[j];
- }
- }
- if (j == pLen)
- return i - j;
- else
- return -1;
- }
向右移動4位后，S[10]跟P[2]繼續匹配。為什么要向右移動4位呢，因為移動4位后，模式串中又有個“AB”可以繼續跟S[8]S[9]對應着，從而不用讓i 回溯。相當於在除去字符D的模式串子串中尋找相同的前綴和后綴，然后根據前綴后綴求出next 數組，最后基於next 數組進行匹配（不關心next 數組是怎么求來的，只想看匹配過程是咋樣的，可直接跳到下文 3.3.4節）。
- ①尋找前綴后綴最長公共元素長度
- 對於P = p0 p1 ...pj-1 pj，尋找模式串P中長度最大且相等的前綴和后綴。如果存在p0 p1 ...pk-1 pk = pj- k pj-k+1...pj-1 pj，那么在包含pj的模式串中有最大長度為k+1的相同前綴后綴。舉個例子，如果給定的模式串為“abab”，那么它的各個子串的前綴后綴的公共元素的最大長度如下表格所示：
比如對於字符串aba來說，它有長度為1的相同前綴后綴a；而對於字符串abab來說，它有長度為2的相同前綴后綴ab（相同前綴后綴的長度為k + 1，k + 1 = 2）。
- ②求next數組
- next 數組考慮的是除當前字符外的最長相同前綴后綴，所以通過第①步驟求得各個前綴后綴的公共元素的最大長度后，只要稍作變形即可：將第①步驟中求得的值整體右移一位，然后初值賦為-1，如下表格所示：
比如對於aba來說，第3個字符a之前的字符串ab中有長度為0的相同前綴后綴，所以第3個字符a對應的next值為0；而對於abab來說，第4個字符b之前的字符串aba中有長度為1的相同前綴后綴a，所以第4個字符b對應的next值為1（相同前綴后綴的長度為k，k = 1）。
- ③根據next數組進行匹配
- 匹配失配，j = next [j]，模式串向右移動的位數為：j - next[j]。換言之，當模式串的后綴pj-k pj-k+1, ..., pj-1 跟文本串si-k si-k+1, ..., si-1匹配成功，但pj 跟si匹配失敗時，因為next[j] = k，相當於在不包含pj的模式串中有最大長度為k 的相同前綴后綴，即p0 p1 ...pk-1 = pj-k pj-k+1...pj-1，故令j = next[j]，從而讓模式串右移j - next[j] 位，使得模式串的前綴p0 p1, ..., pk-1對應着文本串 si-k si-k+1, ..., si-1，而后讓pk 跟si 繼續匹配。如下圖所示：
3.3 解釋
3.3.1 尋找最長前綴后綴
失配時，模式串向右移動的位數為：已匹配字符數 - 失配字符的上一位字符所對應的最大長度值
下面，咱們就結合之前的《最大長度表》和上述結論，進行字符串的匹配。如果給定文本串“BBC ABCDAB ABCDABCDABDE”，和模式串“ABCDABD”，現在要拿模式串去跟文本串匹配，如下圖所示：
- 1. 因為模式串中的字符A跟文本串中的字符B、B、C、空格一開始就不匹配，所以不必考慮結論，直接將模式串不斷的右移一位即可，直到模式串中的字符A跟文本串的第5個字符A匹配成功：
- 2. 繼續往后匹配，當模式串最后一個字符D跟文本串匹配時失配，顯而易見，模式串需要向右移動。但向右移動多少位呢？因為此時已經匹配的字符數為6個（ABCDAB），然后根據《最大長度表》可得失配字符D的上一位字符B對應的長度值為2，所以根據之前的結論，可知需要向右移動6 - 2 = 4 位。
- 3. 模式串向右移動4位后，發現C處再度失配，因為此時已經匹配了2個字符（AB），且上一位字符B對應的最大長度值為0，所以向右移動：2 - 0 =2 位。
- 4. A與空格失配，向右移動1 位。
- 5. 繼續比較，發現D與C 失配，故向右移動的位數為：已匹配的字符數6減去上一位字符B對應的最大長度2，即向右移動6 - 2 = 4 位。
- 6. 經歷第5步后，發現匹配成功，過程結束。
通過上述匹配過程可以看出，問題的關鍵就是尋找模式串中最大長度的相同前綴和后綴，找到了模式串中每個字符之前的前綴和后綴公共部分的最大長度后，便可基於此匹配。而這個最大長度便正是next 數組要表達的含義。
3.3.3 根據《最大長度表》求next 數組
由上文，我們已經知道，字符串“ABCDABD”各個前綴后綴的最大公共元素長度分別為：
而且，根據這個表可以得出下述結論
- 失配時，模式串向右移動的位數為：已匹配字符數 - 失配字符的上一位字符所對應的最大長度值
把next 數組跟之前求得的最大長度表對比后，不難發現，next 數組相當於“最大長度值” 整體向右移動一位，然后初始值賦為-1。意識到了這一點，你會驚呼原來next 數組的求解竟然如此簡單：就是找最大對稱長度的前綴后綴，然后整體右移一位，初值賦為-1（當然，你也可以直接計算某個字符對應的next值，就是看這個字符之前的字符串中有多大長度的相同前綴后綴）。
換言之，對於給定的模式串：ABCDABD，它的最大長度表及next 數組分別如下：
根據最大長度表求出了next 數組后，從而有
失配時，模式串向右移動的位數為：失配字符所在位置 - 失配字符對應的next 值
而后，你會發現，無論是基於《最大長度表》的匹配，還是基於next 數組的匹配，兩者得出來的向右移動的位數是一樣的。為什么呢？因為：
- 根據《最大長度表》，失配時，模式串向右移動的位數 = 已經匹配的字符數 - 失配字符的上一位字符的最大長度值
- 而根據《next 數組》，失配時，模式串向右移動的位數 = 失配字符的位置 - 失配字符對應的next 值
- 其中，從0開始計數時，失配字符的位置 = 已經匹配的字符數（失配字符不計數），而失配字符對應的next 值 = 失配字符的上一位字符的最大長度值，兩相比較，結果必然完全一致。
所以，你可以把《最大長度表》看做是next 數組的雛形，甚至就把它當做next 數組也是可以的，區別不過是怎么用的問題。