sicily 1282 ——由此引出的KMP算法
今天在做有关数据结构字符串处理类的题目,遇到一个蛮有意思的问题,就是sicily 1282 的问题。看了很大串英文,其实就是讲述这样的一个问题:
// 题意: A是主串,B是子串,都由数字组成, 查询B串在A串第一次出现的位置,若找不到则输出no solution
// 注意子串的最大长度是60000,但主串的长度未知,所以要开大些
其实这里蕴含了一个蛮重要的算法,就是KMP算法。这里对不起,我也是百度了一下才知道这个是一个怎么样的算法,先向博客园的用户海子和链接为http://www.cppblog.com/suiaiguo/archive/2009/07/16/90237.html的博客致敬,感谢他们对kmp算法的一个比较详细的讲解,下面由我来转载有关的内容:
KMP算法
在介绍KMP算法之前,先介绍一下BF算法。
一.BF算法
BF算法是普通的模式匹配算法,BF算法的思想就是将目标串S的第一个字符与模式串P的第一个字符进行匹配,若相等,则继续比较S的第二个字符和P的第二个字符;若不相等,则比较S的第二个字符和P的第一个字符,依次比较下去,直到得出最后的匹配结果。
举例说明:
S: ababcababa
P: ababa
BF算法匹配的步骤如下
i=0 i=1 i=2 i=3 i=4
第一趟:ababcababa 第二趟:ababcababa 第三趟:ababcababa 第四趟:ababcababa 第五趟:ababcababa
ababa ababa ababa ababa ababa
j=0 j=1 j=2 j=3 j=4(i和j回溯)
i=1 i=2 i=3 i=4 i=3
第六趟:ababcababa 第七趟:ababcababa 第八趟:ababcababa 第九趟:ababcababa 第十趟:ababcababa
ababa ababa ababa ababa ababa
j=0 j=0 j=1 j=2(i和j回溯) j=0
i=4 i=5 i=6 i=7 i=8
第十一趟:ababcababa 第十二趟:ababcababa 第十三趟:ababcababa 第十四趟:ababcababa 第十五趟:ababcababa
ababa ababa ababa ababa ababa
j=0 j=0 j=1 j=2 j=3
i=9
第十六趟:ababcababa
ababa
j=4(匹配成功)
代码实现:
#include <iostream> #include <vector> #include <string> using namespace std; int BFmatch(string S,string P) { int i,j; i = 0; while(i < S.size()) { j = 0; while(j < P.size() && S[i] == P[j]) { i++; j++; } if(j == P.size()) return i - P.size(); else i = i - j + 1; //回溯 } return -1; }
KMP 匹配算法是由 "Knuth Morris Pratt" 提出的一种快速的模式匹配算法。
hint:不为自身的最大首尾重复子串长度
1.待解决的问题:假设P为给定的子串,T是待查找的字符串,要求从T中找出与P相同的所有子串,这称为模式匹配问题。 (可以给出子串在T中的位置) (下文中提到的P和T分别为子串和目标串)
让我们先来看个例题:
T: t0 t1 t2 t3 .... tm-1 ... tn-1
P: p0 p1 p2 p3 .....pm-1
从T的最左边开始比较,使得 TK = PK,则匹配成功。
2.解决模式匹配问题的方案:
A:朴素的模式匹配算法(思路简单,但不够简便,时间长,有回溯):最简单和最直接的做法,用P中的字符依次与T中的字符进行比较,遇到不相等的字符,则可将P右移一个字符,重新进行比较,直到某次匹配成功或者到达P的最右字符移出T为止。
如:若P="aaaba", T="aaabbaaaba", 则匹配过程如下图
T: a a a b b a a a b a
P: a a a b a
a a a b a
.....
a a a b a
从上不难分析,最坏的情况是“每次比较都在最后一个字符出现不等,每趟最多比较M次,最多比较N-M+1趟,总的比较次数最多为M*(N-M+1)” ,时间复杂性为0(M*N)。 在P右移一位时,不管上一趟比较的中间结果是什么,因此回溯是不可避免的(如:前3个aaa 不需要一位一位的移 ) 。下面我来介绍无回溯的KMP算法。
3.KMP算法解决匹配中哪些主要问题:
A.当字符串比较出现不等时,确定下一趟比较前,应该将P右移多少个字符;
B. P右移后,应该从哪个字符开始和T中刚才比较时不等的那个字符继续开始比较。
我们通过朴素模式匹配的例子来引出问题。在第一次比较过程中失败的是P的第4个字符b,这表明P的前4个字符是成功的。模式P的第3个字符b在它的前3个字符(aaa)中并未出现。因此,在下一次比较时候,至少要将P向后移4个字符;再看P的第一个字符与最后一个字符是相同的,因此将P右移4个字符后,再从第一个字符比较,肯定也是不等的。综上所诉:应该将P右移5个字符,再从P的第0个字符和T的第5个字符开始比较!
KMP算法核心:KMP算法借助于一个辅助数组next来确定当匹配过程中出现不等时,模式P右移的位置和开始比较的位置。next[i]的取值只与模式P本身的前i+1项有关,而与目标T无关。匹配过程中遇到Pi不等于Tj时,若next[i]>=0,则应将P右移i-next[i]位个字符,用P中的第next[i]个字符与Tj 进行比较;若:next[i]= -1,P中的任何字符都不必再与Tj比较,而应将P右移i+1个字符,从P0和Tj+1从新开始下一轮比较(可能不太好理解,自己找个例子,对着话一句一句试试看)
因此只要计算出与模式P相关的next数组,按上面的含义,就可以很容易地给出串的匹配算法。(问题就这样转化了)
C.next的计算:以P = " 01001010100001"为例。
i : 0 1 2 3 4 5 6 .....
P : 0 1 0 0 1 0 1 .....
j(next[i]) : -1 0 0 1 1 2 3 .....
如1:我们要算next[2]的值,有关的为P本身的前2个字符0,1。在字符串01中,寻找出“左右相同的最大字符串,此字符串所含字符的个数就为next[i]的值”而0不等于1,相同字符串不存在,所以next[i] = 0;
如2:我们要算next[6]的值,有关的为P本身前6个字符010010 。此字符串中010 = 010左右相同的最大字符串为010,个数为3。所以next[i]=3;
如3:我们要算next[5]的值,有关的为P本身前5个字符01001。此字符串中 01=01 左右相同的最大字符串为01,个数为2。所以next[i]=2;
我们可以在前面的比较的趟数可以发现:当子串存在左右相同的子子串时,其实我们根本不用每次子串的j移到第一位来,因为我们可以在前面的比较可以知道,前面的各字母都匹配,因此,我们只需把j的坐标前移到那个左右相同的子串的右子串的首位置当中,这样我们就省下了比较的次数。
代码实现方法:
#include <iostream> #include <vector> #include <string> using namespace std; int BFmatch(string S,string P) { int i,j; i = 0; while(i < S.size()) { j = 0; while(j < P.size() && S[i] == P[j]) { i++; j++; } if(j == P.size()) return i - P.size(); else i = i - j + 1; //回溯 } return -1; } //这里求出next数组有两种方法,第一种并不是很好理解,第二种则是直接解决方法 /*第一种方法: 按照递推的思想: 根据定义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]。 因此可以这样去实现: */ vector<int> get_next(string P) { int i = P.size(); vector<int> result(i); int j,k; j = 0; k = -1; result[0] = -1; while(j<P.size()-1) { if(k==-1||P[j] == P[k]) //匹配的情况下,p[j]==p[k] { j++; k++; result[j]=k; } else //p[j]!=p[k] k = result[k]; } return result; } /*第二种方法:直接解决法*/ bool Equals(string 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; } vector<int> get_next_2(string P) { int i,j,k,temp; k = P.size(); vector<int> result(k); for(i = 0;i < k;i++) { if(i == 0) { result[i]=-1; //next[0]=-1 } else if(i==1) { result[i]=0; //next[1]=0 } else { temp=i-1; for(j=temp;j>0;j--) { if(Equals(P,i,j)) { result[i]=j; //找到最大的k值 break; } } if(j==0) result[i]=0; } } } int KMPmatch(string S,string P) { int i,j; vector<int> next; next = get_next(P); while(i < S.size()) { if(j == -1 || S[i] == P[j]) //前一个条件是被迫才返回子串的首位的极端情况 { i++; j++; } else { j = next[j]; //更高级的回溯 } if(j == P.size()) return i-P.size(); } return -1; }
好啦,差不多讲完了,以下是sicily 1282 的答案:
代码实现方法:
#include <iostream> #include <string> #include <vector> using namespace std; vector<int> get_next(const vector<int>& P) { int i = P.size(); vector<int> result(i); int j,k; j = 0; k = -1; result[0] = -1; while(j<P.size()-1) { if(k==-1||P[j] == P[k]) //匹配的情况下,P[j]==P[k] { j++; k++; result[j]=k; } else //p[j]!=p[k] k = result[k]; } return result; } int KMPmatch(const vector<int>& S,const vector<int>& P) { int i,j; vector<int> next; next = get_next(P); //也可以"next = get_next_2(P);" j = 0; i = 0; while(i < S.size()) { if(j == -1 || S[i] == P[j]) //前一个条件是被迫才返回子串的首位的极端情况 { i++; j++; } else { j = next[j]; //更高级的回溯 } if(j == P.size()) return i-P.size(); } return -1; } int main() { int m,n; while(cin >> m) { int i,j; vector<int> A,B; for(i = 0 ; i < m;i++) { cin >> j; A.push_back(j); } cin >> n; for(i = 0; i < n;i++) { cin >> j; B.push_back(j); } if(KMPmatch(B,A) == -1) //注意分清楚谁是主串,谁是子串! cout << "no solution" <<endl; else cout << KMPmatch(B,A) << endl; } return 0; }