Rabin-Karp-MATCHER字符串匹配算法; 一种效率还不错的匹配算法; 思想是关键.

#include <stdio.h> #include <string.h> /*********************************/ * n:文本串T长度 * m:模式串P长度 * h:d^(m-1) * d:进制基数(这里采用26进制) * t[s]:对应位移s的文本串T子串的d进制表示 * p:模式串P的d进制表示 * q:对d进制整数模q,q是素数(越大越容易排出非法位移s,但是过大会导致模运算溢出,这里取13) /*********************************/ const int MAXN = 10000; int n,m,h,p,d,q,t[MAXN]; char T[MAXN],P[MAXN]; /*********************************/ * RabinKarpMatcher()串匹配算法 * 预处理时间：O(n-m+1)+O(m) * 匹配时间最坏:O((n-m+1)*m) * 但实际运行效果一般比这个好 * 预处理：将T[s]与P都转化成d进制整数 * 匹配问题就变成了判断整数T[s]=P * 由于整数可能很大,所以必须作Mod运算 * 这样就导致即便Mod后T[s]=p * 也不能确定是否真的完全相等 * 所以，需要检测这个T[s]是否是伪命中 * 如果Mod后都不相等，则肯定非命中 /*********************************/ int modPow(int x,int y,int z) { int ret=1,i=0; for(;i<y;++i) { ret=(int )( (ret*(long long)x) % z ); // 严格要求 q * d 在一个机器字长内， 即C语言里long long 的64 bits } return ret; } void dNum() { int i=1; p=0; t[0]=0; for(;i<=m;++i) { p= (int ) (( (long long )p*d+(P[i]-'a') ) %d ); t[0]= (int) (((long long)t[0]*d+(T[i]-'a') )%d); } } bool RabinKarpMatcher() { d=26; //26进制数 q=13; //模13 n=strlen(T)-1; m=strlen(P)-1; h=modPow(d,m-1,q); //计算d^(m-1) mod q dNum(); int s,j; bool has=false; for(s=0;s<=n-m;++s) { if(t[s]==p) { bool is=true; for(j=1;j<=m;++j) { if(T[s+j]!=P[j]) { is=false; break; } } if(is) { printf("T中有效位置：%d/n",s+1); has=true; } } if(s<n-m) { // +26*q防止出现运算过程中的负数 t[s+1]=( int ) ( ( d* ( t[s]- ( (T[s+1]-'a') * (long long )h )+ 26*q ) + ( T[s+m+1]-'a') ) %q ); } } return has; } int main() { T[0]=P[0]='z'; printf("输入文本串T，模式串S,以空格/回车作为间隔./n"); scanf("%s%s",T+1,P+1); if(!RabinKarpMatcher()) { printf("对不起,没有匹配成功!/n"); } return 0; }

 

 

描述一下算法的思想:

 

朴素的字符串匹配, 是对文本串T的每一位开始的子串与模式串P进行匹配, 一共有n-m+1位, 每次最坏扫描m位, 所以复杂度O(n(n-m+1))

 

RabinKarp算法是怎么优化这个过程的呢?

 

首先, 讲朴素的字符串匹配变的更简单一些, 把从s位开始的T子串转化为一个整数, 把P串也转化成一个整数, 只要t[s]=p ,即两个串对应的整数相等, 很明显两个串也就匹配了, 举个例子就懂了;

 

假设字符串里只有a,b,c三个字符, 对应的10进制数为: a:0, b:1, c:2;

 

假设文本串T：abc

假设模式串P: ab

 

那么先将P串转化成整数就是0*10+1=1

文本串T的子串转化成整数分别是： T[0]=0*10+1=1;  T[1]=1*10+2=12;

 

其实就是把每个字符对应一个d进制数的1位, 然后像二进制一样, 求出它对应的整数 ,这里转化有个迭代运算方法,比较方便,叫做霍纳法则,可以查一下,代码里也有体现.

 

现在匹配变成了判断T[s]==p ,那么就匹配成功.

 

但是, 如果串P很长, 那么整数会很大很大, 会溢出, 所以必须做一些处理, 就是MOD运算.

 

两个不同的串对应的整数MOD后也可能相等,这样判断起来就没啥意思了, 但是有一个特性, 如果两个串对应的整数的MOD结果不同,那么这两个串不可能相同!

 

所以, 利用这种方法, 可以在朴素的匹配方法的基础上, 利用这个性质直接排除一些位置的判断 ,这样就减小了复杂度.

 

预处理就是求t[s]与p, 单独求每个t[s] 复杂度就是平方级了, 所以这里有一个巧妙的递推方法求所有的t[s].

 

举个例子, 不讲公式了.

 

假设文本串T：abc

假设模式串P: ab

 

T[0]= ab , 对应01

T[1]= (01 - 0*10) *10 +2 =12

 

就是本来ab对应01 , 把a的0去掉，在1的右边加上c=2, 变成12 ,这个过程是可以利用不同进制间的转化的原理用算式算出来的.

 

 

就讲这些,看算法导论应该可以轻松看懂,很简单.