KMP算法詳解：
KMP算法之所以叫做KMP算法是因為這個算法是由三個人共同提出來的，就取三個人名字的首字母作為該算法的名字。其實KMP算法與BF算法的區別就在于KMP算法巧妙的消除了指針i的回溯問題，只需確定下次匹配j的位置即可，使得問題的復雜度由O(mn)下降到O(m+n)。
在KMP算法中，為了確定在匹配不成功時，下次匹配時j的位置，引入了next[]數組，next[j]的值表示P[0...j-1]中最長后綴的長度等于相同字符序列的前綴。
對于next[]數組的定義如下：
1) next[j]=-1? j=0
2) next[j]=max k:0<k<j P[0...k-1]=P[j-k,j-1]
3) next[j]=0? 其他
如：
P????? a??? b?? a??? b?? a
j?????? 0?? 1??? 2?? 3?? 4
next -1? 0??? 0?? 1?? 2
即next[j]=k>0時，表示P[0...k-1]=P[j-k,j-1]
因此KMP算法的思想就是：在匹配過程稱，若發生不匹配的情況，如果next[j]>=0，則目標串的指針i不變，將模式串的指針j移動到next[j]的位置繼續進行匹配；若next[j]=-1，則將i右移1位，并將j置0，繼續進行比較。
代碼實現如下：

int KMPMatch(char *s,char *p) {int next[100];int i , j;i = 0;j = 0;getNext(p , next);while(i < strlen(s)){if(j == -1 || s[i] == p[j]){i++;j++;}else{j = next[j]; //消除了指針i的回溯}if(j == strlen(p))return i - strlen(p);}return -1; }因此KMP算法的關鍵在于求算next[]數組的值，即求算模式串每個位置處的最長后綴與前綴相同的長度， 而求算next[]數組的值有兩種思路，第一種思路是用遞推的思想去求算，還有一種就是直接去求解。
? 1、按照遞推的思想：
?? 根據定義next[0]=-1，假設next[j]=k, 即P[0...k-1]==P[j-k,j-1]
?? 1)若P[j]==P[k]，則有P[0..k]==P[j-k,j]，很顯然，next[j+1]=next[j]+1=k+1;
?? 2)若P[j]!=P[k]，則可以把其看做模式匹配的問題，即匹配失敗的時候，k值如何移動，顯然k=next[k]。
?? 因此可以這樣去實現：
void getNext(char *p,int *next) {int j,k;next[0] = -1;j = 0;k = -1;while(j < strlen(p) - 1){if(k == -1 || p[j] == p[k]) //匹配的情況下,p[j]==p[k]{j++;k++;next[j] = k;}else //p[j]!=p[k]k = next[k];} }?? 2、直接求解方法
void getNext(char *p,int *next) {int i , j , temp;for(i = 0 ; i < strlen(p) ; ++i){if(i == 0){next[i] = -1; //next[0]=-1}else if(i == 1){next[i] = 0; //next[1]=0}else{temp = i - 1;for(j = temp ; j > 0 ; --j){if( equals(p , i , j) ){next[i] = j; //找到最大的k值break;}}if(j == 0)next[i] = 0;}} }bool equals(char *p,int i,int j) //判斷p[0...j-1]與p[i-j...i-1]是否相等 {int k = 0;int s = i - j;for( ; k <= j - 1 && s <= i - 1 ; k++ , s++){if(p[k] != p[s])return false;}return true; } http://poj.org/problem?id=2406

給定一個字符串，問最多是多少個相同子串不重疊連接構成。

KMP的next數組應用。這里主要是如何判斷是否有這樣的子串，和子串的個數。

若為abababa，顯然除其本身外，沒有子串滿足條件。而分析其next數組，next[7] = 5，next[5] = 3，next[3] = 1，即str[2..7]可由ba子串連接構成，那怎么否定這樣的情況呢？很簡單，若該子串滿足條件，則len%sublen必為0。sunlen可由上面的分析得到為len-next[len]。

因為子串是首尾相接，len/sublen即為substr的個數。

若L%(L-next[L])==0,n = L/(L-next[L]),else n = 1

#include<iostream> #include<cstdio> using namespace std;char pattern[1000002]; int next[1000002];/* kmp算法，需要首先求出模式串的next函數值 next[j] = k,說明 p0pk-1 == pj-kpj-1,也就是說k為其前面相等串的長度 */ void get_nextval(const char* pattern) {int i=0,j=-1;next[0]= -1;while(pattern[i] != '\0'){if(j== -1 || pattern[i]== pattern[j] ) //pattern[i]表示后綴的單個字符，pattern[j]表示前綴的單個字符{++i;++j;if(pattern[i] != pattern[j])next[i]=j;elsenext[i]=next[j];}elsej=next[j]; //若j值不相同，則j值回溯} }//get_nextvalint main(void) {int len;while(scanf("%s",pattern)!=EOF){if(pattern[0]=='.')break;len=strlen(pattern);get_nextval(pattern); if(len%(len-next[len])==0)printf("%d\n",len/(len-next[len]));elseprintf("1\n");}return 0; }

http://poj.org/problem?id=1961

大意：
?? 定義字符串A,若A最多由n個相同字串s連接而成，則A=s^n,如"aaa" = "a"^3,"abab" = "ab"^2
?? "ababa" = "ababa"^1
??
給出一個字符串A，求該字符串的所有前綴中有多少個前綴SA= s^n（n>1）
輸出符合條件的前綴長度及其對應的n

? 如aaa
? 前綴aa的長度為2,由2個'a'組成
? 前綴aaa的長度為3，由3個"a"組成

? 分析：KMP
? 若某一長度L的前綴符合上訴條件，則
??? 1.next[L]!=0(next[L]=0時字串為原串，不符合條件)
?2.L%(L-next[L])==0（此時字串的長度為L/next[L]）

?對于2：有str[0]....str[next[L]-1]=str[L-next[L]-1]...str[L-1]
??????? =》str[L-next[L]-1] = str[L-next[L]-1+L-next[L]-1] = str[2*(L-next[L]-1)];
??假設S = L-next[L]-1;則有str[0]=str[s]=str[2*s]=str[3*s]...str[k*s],對于所有i%s==0,均有s[i]=s[0]
??同理，str[1]=str[s+1]=str[2*s+1]....
??????? str[j]=str[s+j]=str[2*s+j]....
??綜上，若L%S==0,則可得L為str[0]...str[s-1]的相同字串組成，
??總長度為L,其中字串長度SL = s-0+1=L-next[L],循環次數為L/SL
???故對于所有大于1的前綴，只要其符合上述條件，即為答案之一

#include<iostream> #include<cstdio> #include<cstring> using namespace std;char pattern[1000002]; int next[1000002];/* kmp算法，需要首先求出模式串的next函數值 next[j] = k,說明 p0pk-1 == pj-kpj-1,也就是說k為其前面相等串的長度 */ void get_nextval(const char* pattern) {int i=0,j=-1;next[0]= -1;while(pattern[i] != '\0'){if(j== -1 || pattern[i]== pattern[j] ){++i;++j;next[i]=j;}elsej=next[j];} }//get_nextvalint main(void) {int i,len,n,j=1;while(scanf("%d",&n)!=EOF){if(!n)break;scanf("%s",pattern);len=strlen(pattern);get_nextval(pattern);printf("Test case #%d\n",j++);for(i=2;i<=len;i++){if(i%(i-next[i])==0 && i/(i-next[i])>1)printf("%d %d\n",i,i/(i-next[i]));}printf("\n");}return 0; }

http://poj.org/problem?id=2752
?大意：
給出一個字符串A,求A有多少個前綴同時也是后綴，從小到大輸出這些前綴的長度。

分析：KMP
對于長度為len的字符串，由next的定義知：
A[0]A[1]...A[next[len]-1]=A[len-next[len]]...A[len-1]此時A[0]A[1]...A[next[len]-1]為一個符合條件的前綴
有A[0]A[1]....A[next[next[len]]-1] = A[len-next[next[len] - next[next[len]]]...A[next[len]-1],故A[0]A[1]....A[next[next[len]]-1]也是一個符合條件的前綴
故從len=>next[len]=>next[next[len]] ....=>直到某個next[]為0均為合法答案，注意當首位單詞相同時，也為答案。

#include<iostream> #include<cstdio> #include<cstring> #include<vector> using namespace std;char pattern[400002]; int next[400002];/* kmp算法，需要首先求出模式串的next函數值 next[j] = k,說明 p0pk-1 == pj-kpj-1,也就是說k為其前面相等串的長度 */ void get_nextval(const char* pattern) {int i=0,j=-1;next[0]= -1;while(pattern[i] != '\0'){if(j== -1 || pattern[i]== pattern[j] ){++i;++j;next[i]=j;}elsej=next[j];} }//get_nextvalint main(void) {int i,len,n;vector<int>ans;while(scanf("%s",pattern)!=EOF){ans.clear();len=strlen(pattern);get_nextval(pattern);n=len;while(n){ans.push_back(n);n=next[n];}if(pattern[0]==pattern[n-1]) //首部、尾部字符相同ans.push_back(1);i=ans.size()-1;for(;i>0;i--)printf("%d ",ans[i]);printf("%d\n",ans[0]);}return 0; }

?

?

總結

以上是生活随笔為你收集整理的KMP算法详解及各种应用的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。