字符串近似匹配算法

　　字符串的近似匹配，就是答应在匹配时有一定的误差，比如在字串“以前高手好久不见”中找“以前是高手”也能成功。具体地说，错误可以有三种类型：加字符（以前也是高手）、漏字符（以前高手）和替换字符（以前石膏手）。下面的函数在text中查找子串pat，最多答应有k个错误。返回的是匹配的终点（我还没想好如何确定起点，呵呵）。

　　至于算法的原理，现在一下子说不清楚，只能说这是一个非确定性有限自动机，以后有时间的话再具体介绍。有爱好的话可以自己去看文章《Faster Approximate String Matching》, Algorithmica (1999) 23: 127-158。

　　算法的限制：(m-k)*(k+2) <= 64, 这里m是子串的长度。那个64是因为哦用了64位整数来编码自动机的状态。假如答应两个错误，则子串最长为18个字符，对一般应用来说足够了。

　　好了，废话少说，看算法吧。看不懂？没事了，哦也是半懂半不懂的。

　　char* amatch(const char* text, const char* pat, int k)

　　{

　　 int m = strlen(pat);

　　 assert(m-k>0);

　　 assert((m-k)*(k+2)<= 64);

　　 int j;

　　 __int64 Din = 0;

　　 __int64 M1 = 0;

　　 __int64 M2 = 0;

　　 __int64 M3 = 0;

　　 __int64 G = 1 << k;

　　 int onekp1 = (1 << (k+1)) - 1;

　　 for (j=0; j

　　 {

　　 Din = (Din << (k+2))onekp1;

　　 M1 = (M1 << (k+2))1;

　　 if (j < m-k-1)

　　 M2 = (M2 << (k+2)) 1;

　　 }

　　 M2=(M2<<(k+2))onekp1;

　　 __int64 D=Din;

　　 const char* s=text;

　　 int c=*s++;

　　 while(c)

　　 {

　　 int found=0;

　　 const char* sp=pat;

　　 for(j=0;j

　　 {

　　 int cp=*sp++;

　　 if(c==cp)

　　 {

　　 found=1;

　　 break;

　　 }

　　 }

　　 if(found)

　　 {

　　 do

　　 {

　　 __int64 tc = 0;

　　 const char* sp = pat;

　　 for (j=0; j

　　 {

　　 int cp = *sp++;

　　 if (c!=cp)

　　 c=(1<

　　 }

　　 __int64 Tc = 0;

　　 for (j=0; j

　　 Tc = (Tc<<(k+2))((tc>>j)&onekp1);

　　 __int64 x = (D>>(k+2))Tc;

　　 D=((D<<1)M1)&((D<<(k+3))M2)&(((x+M1)^x)>>1)&Din;

　　 if((D & G) == 0)

　　 return (char*)s;

　　 if(D != Din)

　　 c = *s++;

　　 }

　　 while ( D != Din && c);

　　 }

　　 if (c)

　　 c = *s++;

　　}

　　return NULL;

　　}