字符串的近似匹配，就是答应在匹配时有一定的误差，比如在字串“以前高手好久不见”中找“以前是高手”也能成功。具体地说，错误可以有三种类型：加字符（以前也是高手）、漏字符（以前高手）和替换字符（以前石膏手）。下面的函数在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-k0);
　　  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; jm-k; 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;jk+1;j++)
　　    {
　　      int cp=*sp++;
　　      if(c==cp)
　　      {
　　        found=1;
　　        break;
　　      }
　　    }
　　    if(found)
　　    {
　　      do
　　      {
　　        __int64 tc = 0;
　　        const char* sp = pat;
　　        for (j=0; jm; j++)
　　        {
　　          int cp = *sp++;
　　          if (c!=cp)
　　          c=(1j);
　　        }
　　        __int64 Tc = 0;
　　        for (j=0; jm-k; j++)
　　        Tc = (Tc(k+2))((tcj)&onekp1);
　　        __int64 x = (D(k+2))Tc;
　　        D=((D1)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;
　　}