一、說明
(1)看到網上同一個字符串求 next 數組的值有兩種,一種是 -1 開頭,一種是 0 開頭,雖然有差別,但是以 0 開頭的next數組的每一項都比以 -1 開頭的next數組的對應項大1,所以,具體是以 0 開頭還是以 -1 開頭看需要吧,算法都是一樣的.KMP 的原始論文 (K,M,P 三個傢伙寫的原文)中是以 0 開頭的,所以下面的寫法是以 0 開頭的.
(2)關於 next 數組的求法,網上能找到很多流行簡潔的寫法,也有很多文章對簡潔代碼講解得非常細緻,然而本文並不是對流行算法的剖析,而只是記錄一下自己比較喜歡的計算方法,並用代碼實現一下.
二、求法的文字描述
(1)第一種求法:根據前一個字符的next值求字符串記作 p;next 數組記作 next;
約定:
- 下標從 1 開始算,注意,不是從 0 開始算
- 字符串長度 >2
1)第一個字母的 next 值置 0 (next[1] = 0),第二個字母的 next 值置 1(next[2] = 1) ;
2)從第 3 個開始,計算第 i 個位置的 next 值時,檢查
p[i-1]== p[next[i-1]] ?(即這兩個值是否相等)
解釋:第 i 個位置的前一個位置的值(即 p[i-1],記作 m)與以 m 的 next 值(即 next[i-1])爲下標的值(即 p[next[i-1]],記作 n)是否相等,(看的懵懵的也沒關係,後面會有例子)
- 若相等,則 next[i] = next[i-1] + 1
若不等,則繼續往回找,檢查
p[i-1]== p[next[next[i-1]]] ?
- 若相等,則 next[i] = next[next[i-1]] + 1
- 若不等,則繼續往回找,直到找到下標爲 1 還不等(即字符串第一個元素),直接賦值 next[i] = 1
(2)第二種求法:根據最大公共元素長度求
首先附上講解的博文地址,裏面有詳細講解
http://blog.csdn.net/v_july_v/article/details/7041827
1)算出每一個字母前綴後綴的最大公共元素長度
2)最大公共元素長度整體向後移動一個長度,最前面的元素值填 -1,即爲 next 數組的第一版本
3)(如果你需要的 next 數組第一個值爲 -1,這步就可以省略了)next 數組的每一個值分別+1,即求得 next 數組。
三、實例
字符串 P =“ababaaababaa”
求解:
(1)對應上面第一種求法
1)初始化
P | a | b | a | b | a | a | a | b | a | b | a | a |
---|---|---|---|---|---|---|---|---|---|---|---|---|
下標 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
next | 0 | 1 |
2)求下標爲 3 的字符的 next 值
P[3-1] = P[2] = ‘b’;
next[3-1] = next[2] = 1 ;
P[next[3-1]] = P[1] = ‘a’;
P[3-1] != P[next[3-1]] ,但是此時已經回溯到了第一個元素,
∴ 直接P[3] = 1 ;
P | a | b | a | b | a | a | a | b | a | b | a | a |
---|---|---|---|---|---|---|---|---|---|---|---|---|
下標 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
next | 0 | 1 | 1 |
3)求下標爲 4 的字符的 next 值
P[4-1] = P[3] = ‘a’;
next[4-1] = next[3] = 1 ;
P[next[4-1]] = P[1] = ‘a’;
P[4-1] == P[next[4-1]] ;
∴ next[4] = next[4-1] + 1 = 2 ;
P | a | b | a | b | a | a | a | b | a | b | a | a |
---|---|---|---|---|---|---|---|---|---|---|---|---|
下標 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
next | 0 | 1 | 1 | 2 |
4)求下標爲 5 的字符的 next 值
P[5-1] = P[4] = ‘b’;
next[5-1] = next[4] = 2 ;
P[next[5-1]] = P[2] = ‘b’;
P[5-1] == P[next[5-1]] ;
∴ next[5] = next[5-1] + 1 = 3 ;
P | a | b | a | b | a | a | a | b | a | b | a | a |
---|---|---|---|---|---|---|---|---|---|---|---|---|
下標 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
next | 0 | 1 | 1 | 2 | 3 |
5)求下標爲 6 的字符的 next 值
推導過程同上 => next[6] = next[6-1] + 1 = 4 ;
P | a | b | a | b | a | a | a | b | a | b | a | a |
---|---|---|---|---|---|---|---|---|---|---|---|---|
下標 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
next | 0 | 1 | 1 | 2 | 3 | 4 |
6)求下標爲 7 的字符的 next 值
P[7-1] = P[6] = ‘a’;
next[7-1] = next[6] = 4 ;
P[next[7-1]] = P[4] = ‘b’;
P[7-1] != P[next[7-1]] && 此時還未回到第一個,繼續
next[next[7-1]] = next[4] = 2 ;
P[next[next[7-1]]] = P[2] = ‘b’;番外(1)
P[7-1] != P[next[next[7-1]]] && 但是此時還未回到第一個,繼續
next[next[next[7-1]]] = next[2] = 1 ;
P[next[next[next[7-1]]]] = P[1] = ‘a’ ;
P[7-1] == P[next[next[next[7-1]]]] ;
∴ next[7-1] = next[next[next[7-1]]] + 1 = next[2] + 1 = 2 ;
P | a | b | a | b | a | a | a | b | a | b | a | a |
---|---|---|---|---|---|---|---|---|---|---|---|---|
下標 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
next | 0 | 1 | 1 | 2 | 3 | 4 | 2 |
7)求下標爲 8 的字符的 next 值
P[8-1] = P[7] = ‘a’;
next[8-1] = next[7] = 2 ;
P[next[8-1]] = P[2] = ‘b’;
P[8-1] != P[next[8-1]] ,但是還沒回到第一個元素,繼續
next[next[8-1]] = next[2] = 1 ;
P[next[next[8-1]]] = P[1] = ‘a’;
P[8-1] == P[next[next[8-1]]];
∴ next[8] = next[next[8-1]] + 1 = 2
P | a | b | a | b | a | a | a | b | a | b | a | a |
---|---|---|---|---|---|---|---|---|---|---|---|---|
下標 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
next | 0 | 1 | 1 | 2 | 3 | 4 | 2 | 2 |
8)求下標爲 9 的字符的 next 值
推導過程同4) => next[9] = next[9-1] + 1 = 3 ;
P | a | b | a | b | a | a | a | b | a | b | a | a |
---|---|---|---|---|---|---|---|---|---|---|---|---|
下標 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
next | 0 | 1 | 1 | 2 | 3 | 4 | 2 | 2 | 3 |
9)求下標爲 10 的字符的 next 值
推導過程同4) => next[10] = next[10-1] + 1 = 4 ;
P | a | b | a | b | a | a | a | b | a | b | a | a |
---|---|---|---|---|---|---|---|---|---|---|---|---|
下標 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
next | 0 | 1 | 1 | 2 | 3 | 4 | 2 | 2 | 3 | 4 |
10)求下標爲 11 的字符的 next 值
推導過程同4) => next[11] = next[11-1] + 1 = 5 ;
P | a | b | a | b | a | a | a | b | a | b | a | a |
---|---|---|---|---|---|---|---|---|---|---|---|---|
下標 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
next | 0 | 1 | 1 | 2 | 3 | 4 | 2 | 2 | 3 | 4 | 5 |
11)求下標爲 12 的字符的 next 值
推導過程同4) => next[12] = next[12-1] + 1 = 6 ;
P | a | b | a | b | a | a | a | b | a | b | a | a |
---|---|---|---|---|---|---|---|---|---|---|---|---|
下標 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
next | 0 | 1 | 1 | 2 | 3 | 4 | 2 | 2 | 3 | 4 | 5 | 6 |
(2)對應上面第二種求法
1)算出每一個字母前綴後綴的最大公共子串長度(下一步會把最後一位移走,所以最後一位可以不算)番外(2)
P | a | b | a | b | a | a | a | b | a | b | a | a |
---|---|---|---|---|---|---|---|---|---|---|---|---|
前後綴最大公共子串長度 | 0 | 0 | 1 | 2 | 3 | 1 | 1 | 2 | 3 | 4 | 5 |
2)最大公共子串長度整體向後移動一個長度,最前面的元素值填 -1,即爲 next 數組的第一版本
P | a | b | a | b | a | a | a | b | a | b | a | a |
---|---|---|---|---|---|---|---|---|---|---|---|---|
next 數組第一版 | -1 | 0 | 0 | 1 | 2 | 3 | 1 | 1 | 2 | 3 | 4 | 5 |
3)(如果你需要的 next 數組第一個值爲 -1,這步就可以省略了)next 數組的每一個值分別+1,即求得 next 數組。
P | a | b | a | b | a | a | a | b | a | b | a | a |
---|---|---|---|---|---|---|---|---|---|---|---|---|
next 數組第二版 | 0 | 1 | 1 | 2 | 3 | 4 | 2 | 2 | 3 | 4 | 5 | 6 |
四、代碼實現
(1)對應上面第一種方法
#include <iostream>
#include <vector>
#include <string.h>
using namespace std;
class Solution{
public:
vector<int> getNext2(string ps){
vector<int> next;
int l = (int)ps.length();
if(l == 0 ){
return next;
}else if(l == 1){
next.push_back(0);
return next;
}else if(l == 2){
next.push_back(0);
next.push_back(1);
return next;
}
char p[20];
strcpy(p, ps.c_str());//字符串轉字符數組
next.push_back(0);
next.push_back(1);
for(int i = 2;i<(int)ps.length();i++){
int k = next[i-1];
while(k!=0){
if(p[i-1] == p[k-1]){//k-1是因爲,在計算機裏,數組下標是從0開始的
next.push_back(k+1);
break;
}else{
k = next[k-1];
}
}
if(k==0) {
next.push_back(1);
}
}
return next;
}
};
(2)對應上面第二種方法
#include <iostream>
#include <vector>
#include <string.h>
using namespace std;
class Solution{
public:
vector<int> getNext2(string ps){
vector<int> next;
int l = (int)ps.length();
if(l == 0 ){
return next;
}else if(l == 1){
next.push_back(0);
return next;
}
next.push_back(0);//next數組第一個值爲0
for(int i = 0; i < l-1; i++ ){//最後一個最大公共子串長度不用算
//計算每一個子字符串的前綴後綴最大公共子串長度
int l = max_pub_substr(ps.substr(0,i+1));
//右移後+1
//for循環之前已加了一個數據0進next數組,此時再加進去元素時,元素在next數組裏的下標比得到該元素值的子串最後字符的下標大1,也就相當於向後移一位了
next.push_back(l+1);
}
return next;
}
//計算前綴後綴的最大公共子串長度
int max_pub_substr(string ps){
int l = (int)ps.length();
if(l == 0 || l == 1){
return 0;
}
char p[20];
strcpy(p, ps.c_str());//字符串轉字符數組
int len = 0;
int m = -1;//最後一個字符(不包括)之前與最後一個字符相等的字符下標 m
int k = -1;//已經查找過的字符下標
while( k != l-1 ){
k = m+1;
for(; k < l-1; k++){
if(p[k] == p[l-1]){
m = k;
break;
}
}
if( m==-1 || k==l+1){//表示沒有與最後一個字符相等的字符
return len;
}else{//檢查前綴串和後綴串是否相等
int i = 0,j = l-1-m;
for(; i <= m,j < l; i++,j++){//i前綴下標,j後綴下標
//只要有不相等的就失敗
if(p[i] != p[j]){
break;
}
}
if( i == m+1 ){//說明前後串相等,因爲全都比較了,沒有中斷
len = m+1;
}
}
}
return len;
}
};
五、驗證
int main(){
string s = "ababaaababaa";
Solution slt;
vector<int> next = slt.getNext2(s);
vector<int>::iterator it;
for( it = next.begin(); it != next.end(); it++){
cout<<*it;
}
return 0;
}
六、番外
(1)在這個地方,我們可以發現,P[2] == P[4] == ‘b’ ,由於P[4] != P[6] ,∴ P[2] != P[6] 是一定的,就可以跳過 P[2] 和 P[6] 的比較,直接比較 P[1] 和 P[6];
(2)前綴後綴的最大公共元素長度
前綴:簡單來說,也就是,從第一個字母(必包括)開始往後看到最後一 個字母(不包括)爲止的字符串的以第一個字母開頭的子串
(比如“abab”的前綴有a,ab,aba);後綴:簡單來說,也就是,從最後一個字母(必包括)開始往前看到第一個字母(不包括)爲止的字符串的子串
(比如“abab”的後綴有b,ab,bab);最大公共子串長度:也就是前綴和後綴擁有的相同子串的最大長度
以“abab”爲例:
模式串的各個子串 | 前綴 | 後綴 | 最大公共元素長度 |
---|---|---|---|
a | 空 | 空 | 0 |
ab | a | b | 0 |
aba | a,ab | a,ba | 1 |
abab | a,ab,aba | b,ab,bab | 2 |
一種稍微快一點的小方法:
“abab”前後綴的公共子串必然是以 a(字符串第一個字母) 開頭,b(字符串最後一個字母)結尾的子串,“abab”的前綴串中滿足條件的子串集合爲A={“ab”},後綴串中滿足條件的子串集合爲B={“ab”},再找出A,B集合中相等的子串集合C,最後算出C中最長子串的長度即爲最大公共子串長度。
好啦~~~寫了這麼多,我自己都懶得看T_T