第三十二章 字符串匹配

设T为全局查询域，P为要查询的字符串，查询结果是：返回一个或多个距离T开始的偏移
后缀：字符串A是字符串D=X+A的后缀,记A -} D
前缀：字符串A是字符串D=A+x的前缀,机A {- D

朴素算法

这个算法就是每个人都能想到的最朴素的算法
算法：

naive_string_matcher(T,P)
    n=T.lenth
    m=P.lenth
    for s=0 to n-m
        if P[1...m]==T[s+1...s+m]
            printf s

代码实现：

Rabin-Karp

我们主要是体会一下这个算法思想，因为它假设字符出自集合{0,1,2...9}（10进制，所以设变量d=10）这样就可以将要查询的P看成一个m=P.length位的数，然后对一个数q求模。如果两个m位字符串代表的数模q相等，则这两个字符串才有可能相等，进一步判断如果相等输出偏移量。

1、先求出h=d^m-1(mod q)

2、求出P和T的前m个字符串代表数的模p=P[1,2,...m]（mod q）、 t0=T[1,2,...m](mod q)的值

3、已知t(i)的值，我们能在常数时间求出t(i+1)的值,根据公式
   t(s+1)=(d*(t(s)-T[s+1]*h)+T[s+m+1])mod q     t(s)=T[s+1,s+2,....s+m](mod q)

算法：

ranin_karp_matcher(T,P,d,q)
    n=T.length
    m=P.length
    h=d(m-1)mod q
    p  for i=1 to m //除法求余
        p=(d*p+P[i])mod q
        t0=(d*t0+T[i])mod q
    for s=0 to n-m
        if p==t(s)
            if P[1...m]==T[s+1...s+m]
                printf s
        if s<n-m
            t(s+1)=(d*(t(s)-T[s+1]*h)+T[s+m+1])mod q

代码实现：


我们也可以将P的m的字符求和然后模q，p=(P[1]+P[2]+...P[m])mod q
然后求出t0=(T[1]+T[2]+...T[m])mod q,也可以在常数时间内求出t(s+1)
根据公式：t(s+1)=(t(s)-T[s]+T[s+m+1])mod q

有限自动机

状态0：T[s]!=P[1]
状态1：P[1]
状态2：P[1]->P[2]
状态3：P[1]->P[2]->P[3]
.
.
.
状态m：P[1]->P[2]->P[3]...->P[m]

如果T中存在字符串P则T中一定存在一个这样的状态P[1]->P[2]...->P[m]，只有m状态才是正确匹配到了P

当在状态i的时候，设T[k]=P[i]如果T[k+1]!=P[i+1],则状态不会转移到i+1。那么状态会转移到什么呢？答案是任何<i的状态都有可能，这是需要经过计算的。
存在字符串A是P[1,2,...i]的后缀&&是P的前缀，我们转移到最长A的状态中，因为这是紧接下来的第一个可能成功匹配的偏移。(这一点将会在后面证明)

设集合G={T中出现过的字符}，我们把状态 i 经过字符c(each c from G)转移到状态 j 计算出来并保存到一个二维数组theta中即j=theta(i,c)

例如：G={a,b,c} P=ababaca 结果如图：



计算theta的一种算法如下
算法：

compute_transition_function(P,G)
    m=P.length
    for q=0 to m
        for(each charater a from G)
            k=min(m+1,q+2)//仔细斟酌 k= 1 to m+1
            do
                k=k-1
            //P[1..k]是P[1..q]+a的后缀，由k=k-1可知这里去的是最长的A
            while P[1,2,...k]-}P[1,2,...q]+a  //k=0时空字符串是任何字符串的后缀
            theta(q,a)=k

计算出theta后就可以在线性时间完成匹配

算法:

finite_automaton_matcher(T,theta,m)
    n=T.length
    q=0
    for i=1 to n//注意是[0,n]
        q=theta(q,T[i])
        if q==m
            print i-m

代码实现:

Knuth-Morris-Pratt

定义:pai[i]的值为最长P[1...i]的真后缀同时是P[1....m]的前缀的长度

我们先假设:"每当T[s+1...s+i]的下一个字符不能匹配时，将偏移s向前移i-pai[i]位(s=s+i-pai[i])继续向前匹配，这样能匹配到所有的结果"是正确的

现在来说明假设的正确性
T[s+1...s+i]能正确匹配，T[s+i+1]不能。此时我们将s直接向前移动i-pai[i]位，那么接下来的pai[i]位与P[1...pai[i]]是匹配的，可以继续向前匹配。只要说明之间跳过的点不能匹配到正确结果就可证明假设成立。

如果s到s+i-pai[i]之间有能够正确匹配的，那么存在一个s'使得T[s'+1...s+i]是P[1...m]的前缀，且值大于pai[i]。这与pai[i]最长矛盾。

求这样一个pai的原因是:如果T[s+1...s+i]与P[1...i]匹配,下一个不能匹配即T[s+i+1]!=P[i+1]。站在偏移s处可以看到T[s+1...s+i]的值，因为我们知道P[1...i]的值，他们两者相等！所以应该预先求出每个P[1...i]的pai[i]，以免每次求最长T[s+1....s+i]的真后缀同时是P[1...m]的前缀。根据pai[i]的值，于是我们设置偏移s=s+i-pai[i]。

如何计算pai

    现在pai[i]的值为k，如果能匹配就pai[i+1]=k+1。如果不能匹配就递归的考虑与P[i+1]能否匹配，能匹配时pai[i+1]=k+1,不能匹配时k=pai[k]。直到k=0时结束,并令pai[i+1]=0。

当pai[i]=k=0时，就回到了最初的匹配，P[i+1]是否等于P[k+1]。

算法:

compute_prefix_function(P)
	m=P.length
	let pai[1...m] be a new array
	pai[1]=0
	k=0
	for q = 2 to m//find q <--> k
		while k>0 and P[k+1]!=P[q]
			k=pai[k]
		if P[k+1]==P[q]
			k=k+1
		pai[q]=k
	return pai

kmp算法:

KMP_matcher(T,P)
	n=T.length
	m=P.length
	pai=COMPUTE_PREFIX_FUNCTION(P)
	q=0						//number of characters matched
	for i = 1 to n 				//scan the text from left to right
		while q>0 and T[i+1]!=P[q]		
			q=pai[q]			//next character does not match
		if T[i+1]==P[q]	
			q=q+1
		if q==m 				//is all of P matched
			print "Patter occurs with shift" i-m
			q=pai[q]			//look for the next match

代码实现:

未完待续...