程式員必知演算法—-KMP演算法系列（1）

KMP演算法是拿來處理字串匹配的。換句話說，給你兩個字串，你需要回答，B串是否是A串的子串（A串是否包含B串）。比如，字串A="I'm matrix67"，字串B="matrix"，我們就說B是A的子串。

解決這類問題，通常我們的方法是枚舉從A串的什麼位置起開始與B匹配，然後驗證是否匹配。假如A串長度為n，B串長度為m，那麼這種方法的複雜度是O
(mn)的。雖然很多時候覆雜度達不到mn（驗證時只看頭一兩個字母就發現不匹配了），但我們有許多“最壞情況”，比如，A= "aaaaaaaaaaaaaaaaaaaaaaaaaab"，B="aaaaaaaab"。我們將介紹的是一種最壞情況下O(n)的演算法（這裡假設 m<=n），即傳說中的KMP演算法。

假如，A="abababaababacb"，B="ababacb"，我們來看看KMP是怎麼工作的。我們用兩個指標i和j分別表示，A[i-j+
1..i]與B[1..j]完全相等。也就是說，i是不斷增加的，隨著i的增加j相應地變化，且j滿足以A[i]結尾的長度為j的字串正好匹配B串的前 j個字元（j當然越大越好），現在需要檢驗A[i+1]和B[j+1]的關係。當A[i+1]=B[j+1]時，i和j各加一；什麼時候j=m了，我們就說B是A的子串（B串已經整完了），並且可以根據這時的i值算出匹配的位置。當A[i+1]<>B[j+1]，KMP的策略是調整j的位置（減小j值）使得A[i-j+1..i]與B[1..j]保持匹配且新的B[j+1]恰好與A[i+1]匹配（從而使得i和j能繼續增加）。我們看一看當
i=j=5時的情況。

    i = 1 2 3 4 5 6 7 8 9 ……
    A = a b a b a b a a b a b …
    B = a b a b a c b
    j = 1 2 3 4 5 6 7

    此時，A[6]<>B[6]。這表明，此時j不能等於5了，我們要把j改成比它小的值j'。j'可能是多少呢？仔細想一下，我們發現，j'必須要使得B[1..j]中的頭j'個字母和末j'個字母完全相等（這樣j變成了j'後才能繼續保持i和j的性質）。這個j'當然要越大越好。在這裡，B
[1..5]="ababa"，頭3個字母和末3個字母都是"aba"。而當新的j為3時，A[6]恰好和B[4]相等。於是，i變成了6，而j則變成了 4：

    i = 1 2 3 4 5 6 7 8 9 ……
    A = a b a b a b a a b a b …
    B =     a b a b a c b
    j =     1 2 3 4 5 6 7

    從上面的這個例子，我們可以看到，新的j可以取多少與i無關，只與B串有關。我們完全可以預先處理出這樣一個數組P[j]，表示當匹配到B數組的第j個字母而第j+1個字母不能匹配了時，新的j最大是多少。P[j]應該是所有滿足B[1..P[j]]=B[j-P[j]+1..j]的最大值。
    再後來，A[7]=B[5]，i和j又各增加1。這時，又出現了A[i+1]<>B[j+1]的情況：

    i = 1 2 3 4 5 6 7 8 9 ……
    A = a b a b a b a a b a b …
    B =     a b a b a c b
    j =     1 2 3 4 5 6 7

    由於P[5]=3，因此新的j=3：

    i = 1 2 3 4 5 6 7 8 9 ……
    A = a b a b a b a a b a b …
    B =         a b a b a c b
    j =         1 2 3 4 5 6 7

    這時，新的j=3仍然不能滿足A[i+1]=B[j+1]，此時我們再次減小j值，將j再次更新為P[3]：

    i = 1 2 3 4 5 6 7 8 9 ……
    A = a b a b a b a a b a b …
    B =             a b a b a c b
    j =             1 2 3 4 5 6 7

    現在，i還是7，j已經變成1了。而此時A[8]居然仍然不等於B[j+1]。這樣，j必須減小到P[1]，即0：

    i = 1 2 3 4 5 6 7 8 9 ……
    A = a b a b a b a a b a b …
    B =               a b a b a c b
    j =             0 1 2 3 4 5 6 7

    終於，A[8]=B[1]，i變為8，j為1。事實上，有可能j到了0仍然不能滿足A[i+1]=B[j+1]（比如A[8]="d"時）。因此，準確的說法是，當j=0了時，我們增加i值但忽略j直到出現A[i]=B[1]為止。

預先處理不需要按照P的定義寫成O(m^2)甚至O(m^3)的。我們可以通過P[1],P[2],...,P[j-1]的值來獲得P[j]的值。對於剛才的B="ababacb"，假如我們已經求出了P[1],P[2],P[3]和P[4]，看看我們應該怎麼求出P[5]和P[6]。P[4]=2，那麼P
[5]顯然等於P[4]+1，因為由P[4]可以知道，B[1,2]已經和B[3,4]相等了，現在又有B[3]=B[5]，所以P[5]可以由P[4] 後面加一個字元得到。P[6]也等於P[5]+1嗎？顯然不是，因為B[ P[5]+1 ]<>B[6]。那麼，我們要考慮“退一步”了。我們考慮P[6]是否有可能由P[5]的情況所包含的子串得到，即是否P[6]=P[ P[5] ]+1。這裡想不通的話可以仔細看一下：

        1 2 3 4 5 6 7
    B = a b a b a c b
    P = 0 0 1 2 3 ?

    P[5]=3是因為B[1..3]和B[3..5]都是"aba"；而P[3]=1則告訴我們，B[1]、B[3]和B[5]都是"a"。既然P[6]不能由P[5]得到，或許可以由P[3]得到（如果B[2]恰好和B[6]相等的話，P[6]就等於P[3]+1了）。顯然，P[6]也不能通過P[3]得到，因為B[2]<>B[6]。事實上，這樣一直推到P[1]也不行，最後，我們得到，P[6]=0。
    怎麼這個預先處理過程跟前面的KMP主程式這麼像呢？其實，KMP的預先處理本身就是一個B串“自我匹配”的過程。

下面是一種KMP實現演算法：

package com.algorithm.stringsearch;//子字串尋找，KMP演算法public class KnuthMorrisPratt {private int[][] dfa;private String pat;public KnuthMorrisPratt(String pat){this.pat=pat;int R=256,M=pat.length();dfa=new int[R][M];dfa[pat.charAt(0)][0]=1;for(int X=0,j=1;j<M;j++){for(int c=0;c<R;c++){dfa[c][j]=dfa[c][X];}dfa[pat.charAt(j)][j]=j+1;X=dfa[pat.charAt(j)][X];}}public int search(String str){int i,j,N=str.length(),M=pat.length();for(i=0,j=0;i<N&&j<M;i++){j=dfa[str.charAt(i)][j];}if(j==M){return i-M;}else{return N;}}public static void main(String[] args){String t1="bcbaabacaababacaa";String t2="ababac";KnuthMorrisPratt kmp=new KnuthMorrisPratt(t2);System.out.println(kmp.search(t1));}}