字符串匹配算法

    KMP算法,以为一个简简单单的算法,看了我一天时间竟然没有看懂...果然图样图撕破了,三位大师提出的算法岂是我等屌丝能够迅速的理解的?不过话说看了这次算法才知自己的智力有多么的吃紧,还是要努力学习呀~智力不行就要加把劲了。(接下来字符串匹配算法均参考算法导论)

    字符串匹配,算法的模型不用提出大家都知道,仅仅是在文本T字符串中精确匹配模式串P,简简单单,轻轻松松的就知道这么一个模型,自然而然的能够想到一个最笨最实用的算法,朴素算法,朴素算法就是逐个比对,然后在文本串中下移一位在进行逐个比对,算法复杂度O((n-m+1)m),

    不过这种简单的方法的时间复杂度不是我们能够容忍的,提高一点有一个Rabin-Karp的算法,此算法的最坏时间复杂度没有提高,但是平均情况比较好,而且它这个思想可以借鉴,就是把匹配当做算术运算,后来取模比对,针对剩余的少部分精确比对~不过这不是重点,

    接下来的就是重量级的算法,KMP算法,它在预处理时间和匹配时间均达到了线性时间~O(m)的预处理时间,O(n)的匹配时间,非常完美的理论,不是么?网上很多资料都是关于next函数的,这里我参考算法导论里面的KMP算法,其思想虽然一致,但是不同于next函数的原理,其原理如下:(匹配过程)

 

 i  1 2 3 4 5 6

    a b a b a b a a b a b 

    a b a b a c b

          a b a b a c b  

        j 1 2 3 4 5 6 7  

  j 1 2 3 4 5 6

 

    这里比对过程是i和j的变化,如果i和j对应的地方相同,则同时+1,继续走下去,当出现T[i]和P[j]出现不同时,如上图中的P[6]!=T[6],此时KMP考虑的是i不进行回溯,而是考虑挪动j,使得j变化为一个更小的值,小于j,这样的变化效果是P整体向后移,但是此时不能够导致T[6]前面的i的匹配性质,及挪动后T[6]前面的元素和P对齐之后还是要相同的,所以这里j=5改为j=3,挪动后效果如红色标注的P所示,这是T[6]=P[4],两个串的表示i和j可以挪动下去;

 i  1 2 3 4 5 6 7 8 9 10 11

    a b a b a b a a b a b 

     

          a b a b a c b  

                a b a b a c b

                      3

                      a b a b a c b

                      1

                         a b a b a c b

                      0

        j 1 2 3 4 5 6 7  

    但是接下来挪动的时候又产生了问题,T[8]!=P[6],这时候如同上面的方式,挪动j=5的位置,首先挪动至最近的保持T[8]前保持性质的部分,其实这里保持性质及P[5]的后缀的最长前缀...说到概念可能就不知道了,还是理解保持性质吧,挪动至红色后发现T[8]!=P[4],所以这里还要挪动j=3的位置,挪动成j=1,还是不能满足,所以还需要挪动,这时j=0了,及这时候T[8]和P[1]比较了,这里刚好一样,所以i可以继续向后挪动了;

    以上的移动均是参考了一个数字,该数字是保证某个位置的时候P和T能够保持性质,但是这个性质仅仅和P有关,及上面说的P的后缀的最长前缀,因为以上匹配过程用到了这个数据,所以接下来就是这个数据的计算的算法了,其实这个算法才是让我纠结的地方,纠结了好久,这里发现一个可以很容易理解的地方,分享给大家;

    上面算法的线性时间需要用到均摊分析的知识~可以仔细思考一下,线性的时间,

    这里图解一下计算后缀的最长前缀吧,这里这个记为PI[j],这里PI[j]可以根据PI[1],PI[2]...PI[j-1]计算得出,

    

    如图所示,PI[j-1]为标记的凸包的长度,这里如果P[lengh[PI[j-1]]+1]=P[j],这里PI[j]及为PI[j-1]长度加1,如果P[lengh[PI[j-1]]+1]!=P[j],则这个需要在更加前面找,这里及递归的找,画图如下,

    

    及黑色线标注的位置是否与P[j]相同选择是否继续递归,黑色标注的位置的选择为PI[ PI[j-1] ] + 1,PI[j-1]的位置为红色的那段,因为不可能为红色,所以要缩小一下,这里示意为绿色的圈,绿色的圈挪动到前边的红色部位,所以绿色的圈在红色的部位找到前缀为黑色的部分,所以PI[ PI[j-1] ]是这样得出的,这样递归下去就能够得出PI[j]的值了,这样就可以根据计算得出的PI[j]值运用匹配算法了,

    不知道上面的解释是否能够解释的清楚,一个递归的过程,分析算法复杂度也是一个均摊分析的方法,同样是线性的,

 

    模式串的预处理的伪代码如下:

COMPUTE-PREFIX-FUNCTION(P)
    m=length(P) 
    PI[1]=0               //初始化
    k=0                    //初始化
    for q=2 to m
        while k>0 and P[k+1]!=P[q] //结束条件至0或者相等
            k=PI[k]                             //递归的过程
        if P[k+1]=P[q]      //               增加的过程
            k=k+1
        PI[q]=k                         //赋值为k,下一个计算已k为起点向下递归
    return PI

  KMP匹配过程执行的伪代码如下:

KMP-MATCH(T,P)
    n = length[T]
    m = length[P]
    PI=COMPUTE-PREFIX-FUNCTION(P)
    j=0
    for i=1 to n
        while j>0 and P[j+1]!=T[i]  //如果不等,挪动P,根据计算好的PI
            j=PI[j]
        if P[j+1]=T[i] //如果相等,则向后继续匹配
            j=j+1
        if j=m            //匹配m个后则成功
            printf(匹配成功)
            j = PI[j]
       

  以上是伪代码描述,上面说描述的参考算法导论的KMP思想,网上还有一种next方式的,有空研读一下比较差别;

     除了上述算法还有一些优秀的字符串匹配算法,基于自动机的,BM算法等等,

 如果想要了解一下有限自动机方法可以继续看下去,这种方法可KMP算法可以看做等价,

 有限自动机字符串匹配算法简单介绍如下:

给定模式P[1...m],其对应的字符串匹配自动机定义如下:

1、状态集Q为{0,1,...,m},初始状态q0为0状态,状态m是唯一的接受状态。

2、对于任意的状态q和字符a,变迁函数δ由如下等式定义:δ(q,a)=σ(Pq a)

这里的解释一下σ(x)的定义,其为相应P的后缀函数。σ(x)为x的后缀 P的最长前缀的长度:σ(x)=max{k:Pk是x的后缀}

简单的举例如下:

i         1 2 3 4 5 6 7 8 9 10 11 

T[i]    a  b a b a b a c  a  b   a 

状态   1 2  3 4 5  4 5 6  7 2  3  

上述是匹配的过程,下面是转移表:

      a    b     c              P

0    1     0     0            a    

1    1     2     0            b

2    3     0     0            a

3    1     4     0            b

4    5     0     0            a

5    1     4     6            c

6    7     0     0            a

7    1     2     0 

自动机的过程与KMP可以转换,只不过自动机考虑了T[i]不匹配过程中的具体字母表的转移,然后KMP只是不匹配的情况下先进行挪动,挪动后发现不匹配之后再进行挪动?直至挪动为0的时候,抑或是一直不匹配i++,此时忽略j;自动机只是具体考虑了此时如果T[i]如果不等于P[j],并且此时T[i]的具体取值已经指定,在此值指定的情况下应该怎样的转移~

a  b  a  b  a  c  a

0  0  1  2  3  0  1

上面是KMP计算出的模式函数,首先a值是T[i]和P[1]如果相等,则j++,向后移动,但是如果不匹配,此时如同自动机转移表第一行,为b or c,此时就应该i,j同时++了,此时KMP如果发现T[i]和P[1]不相等,则上面算法i++,j取值仍为0,等价于i和j同时++了;

这时考虑b,如果a匹配了,P[2]和T[i]匹配,此时j++=2了,这时候移动两位了,自动机表现匹配两个字母,所以为状态2,但是如果不相等呢?此时考虑了b,必定T[i]和P[1]已经匹配了,KMP中不匹配则考虑移动P,根据值j重新改为0,及向右移动两位,然后自动机此时读入不等的可能为a或者c,如果为a,则KMP移动两位之后匹配上了一位,j++=1,如果为c,移动之后仍然不能匹配,所以i和j同时仍然移动,KMP表现i++,j重新赋值为0;

...

这次考虑一个中间的值,比如c的位置,如果知道T[i]值为多少,则可以知道具体的移动多少,然而KMP中是根据P计算的模式值,所以这里不知道T[i]的值,它有可能是最坏的值,所以这里取得的是最坏的值;所以这里计算自动机转移函数可以考虑KMP中已经计算好的结果,这样提升时间复杂度,

...

所以自动机匹配和KMP算法有一定的等价性,上面的描述比较凌乱,希望能够对你有所启发,

posted @ 2012-12-14 00:06  weixliu  阅读(4281)  评论(1编辑  收藏