朴素字符串匹配与Karbin-Karp算法



     字符串的精度匹配就是在文本T中找出模式P的精确副本，并求出匹配的位置下标。即如果P[0...m-1]==T[k...k+m-1] ,则称P与T的子序列匹配成功。我们要找出所有匹配成功的k。

     朴素字符串匹配方法很简单。从文本T的第一个字母和模式P的第一个字母开始比较。如果不匹配，就从T的第二个字母开始匹配，依次类推，不保留所有有用得信息。设P和T的长度分别为m和n .这种算法有两层循环，没有预处理时间，算法时间复杂度为O(nm)。

void Naive_String_Match(string T, string P){
	int n,m,pos,i;
	n = T.size();
	m = P.size();
	pos = i = ans=0;
	while (pos <=n - m){
		i = 0;
		while (i < m&&P[i] == T[pos + i])
			i++;
		if (i == m)    //循环跳出时当 i==m就表示匹配成功
			postion[ans++] = pos;
		pos++;
	}
}

其中postion[]数组保存了匹配成功的 k 值。

另外一种改进的办法叫做Rabin-Karp算法。这个算法在实际应用中可以较好的运行。Rabin-karp算法预处理时间是O(m) .平均运行时间是O(n)（m<=n）,在最坏情况下运行时间为O(mn) .首先在初等数论中有以下结论 ：

    设 a,b,q为3个正整数，则有：

                         1）(a+b) mod q= (a%q+b%q)%q

                         2）a×b mod q =(a mod q)×(b mod q) mod q

设组成T和P的字符组成的集合是 A，例如A={'a','b'...'z'} .则A中字符的个数记为 |A| .算法的核心思想是将模式p通过一个hash函数映射为一个整数值 ,也将于p匹配的那部分T[pos...pos+m-1]映射为一个整数值,如果hash[p]！=hash[T]则他们一定不匹配，但是如果hash[T]==hash[p]则不一定匹配，这时候需要一个一个字母的比较。至于计算hash[p]，我们可以通过霍纳法则来求，时间为O(m).

而对于hash[T]的值,我们需要开始计算出T[0...m-1]的值H(0)，在计算H(t)时不需要重新计算，可以通过H(t-1)获得：

                         H(t)=((H(t-1)-T[pos])*|A|^m)*|A|+T[pos+m] ）mod Prime;

这个式子使用的|A|进制,同时需要一个素数作为模运算。在一开始就可以把中间|A|^m计算出来，于是可以不用每次都计算|A|^m.具体代码如下，选择的是A={'a','b'...'z'},即26进制：

#include<iostream>
#include<string>
using namespace std;
#define p 82595483
void Match(string W, string T);
int postion[1001];
int ans;
int main(){
	int i;
	string W, T;
	cin >> W >> T;
	Match(W, T);
	for (i = 0; i < ans; i++)
		cout << postion[i] << endl;
	return 0;
}
void Match(string W, string T){
	int pos, n, m, i, t,h,d;
	n = T.size();
	m = W.size();
	h=t =pos=ans=0;
	d = 1;
	for (i = 0; i < m; i++){
		t = (t * 26 + W[i] - 'a') % p;      
		h = (h * 26 + T[i] - 'a') % p;
		d = (d * 26) % p;
	}
	while (pos <=n-m){
		if (h == t){
			i = 0; 
			while (i < m&&W[i] == T[i + pos])
				i++;
			if (i == m)
				postion[ans++]=pos;
		}
	    h = (26 * h - (T[pos] - 'a')*d + (T[pos + m]-'a')) % p;
		pos++;
	}
}