經典演算法研究系列：六、教你從頭到尾徹底理解KMP演算法

6、教你從頭到尾徹底理解KMP演算法

 

作者： July  、 saturnma     時間； 二零一一年一月一日

-----------------------

本文參考：資料結構（c語言版） 李雲清等編著、演算法導論
作者聲明：個人July 對此24個經典演算法系列，享有著作權，轉載請註明出處。

引言：
在文本編輯中，我們經常要在一段文本中某個特定的位置找出 某個特定的字元或模式。
由此，便產生了字串的匹配問題。
本文由簡單的字串匹配演算法開始，經Rabin-Karp演算法，最後到KMP演算法，教你從頭到尾徹底理解KMP演算法。

來看演算法導論一書上關於此字串問題的定義：
假設文本是一個長度為n的數組T[1...n]，模式是一個長度為m<=n的數組P[1....m]。
進一步假設P和T的元素都是屬於有限字母表Σ.中的字元。

依據，再來解釋下字串匹配問題。目標是找出所有在文本T=abcabaabcaabac中的模式P=abaa所有出現。
該模式僅在文本中出現了一次，在位移s=3處。位移s=3是有效位移。

 

一、簡單的字串匹配演算法

簡單的字串匹配演算法用一個迴圈來找出所有有效位移，
該迴圈對n-m+1個可能的每一個s值檢查條件P[1....m]=T[s+1....s+m]。

NAIVE-STRING-MATCHER(T, P)
1 n ← length[T]
2 m ← length[P]
3 for s ← 0 to n - m
4     do if P[1 ‥ m] = T[s + 1 ‥ s + m]         
      //對n-m+1個可能的位移s中的每一個值，比較相應的字元的迴圈必須執行m次。
5           then print "Pattern occurs with shift" s

簡單字串匹配演算法，針對文本T=acaabc 和模式P=aab。
上述第4行代碼，n-m+1個可能的位移s中的每一個值，比較相應的字元的迴圈必須執行m次。
所以，在最壞情況下，此簡單模式比對演算法的已耗用時間為O（(n-m+1)m）。

 

--------------------------------

下面我再來舉個具體例子，並給出一具體運行程式：
對於目的字串target是banananobano,要匹配的字串pattern是nano,的情況，

下面是匹配過程，原理很簡單，只要先和target字串的第一個字元比較，
如果相同就比較下一個，如果不同就把pattern右移一下，
之後再從pattern的每一個字元比較，這個演算法的運行過程如。
//index表示的每n次匹配的情形。

#include<iostream>
#include<string>
using namespace std;
int match(const string& target,const string& pattern)
{
    int target_length = target.size();
    int pattern_length = pattern.size();
    int target_index = 0;
    int pattern_index = 0;
    while(target_index < target_length && pattern_index < pattern_length)
    {
        if(target[target_index]==pattern[pattern_index])
        {
            ++target_index;
            ++pattern_index;
        }
        else
        {
            target_index -= (pattern_index-1);
            pattern_index = 0;
        }
    }
    if(pattern_index == pattern_length)
    {
        return target_index - pattern_length;
    }
    else
    {
        return -1;
    }
}
int main()
{
    cout<<match("banananobano","nano")<<endl;
    return 0;
}

//運行結果為4。

 

上面的演算法進間複雜度是O(pattern_length*target_length),
我們主要把時間浪費在什麼地方呢，
觀查index =2那一步，我們已經匹配了3個字元，而第4個字元是不匹配的，這時我們已經匹配的字元序列是nan,

此時如果向右移動一位，那麼nan最先匹配的字元序列將是an,這肯定是不能匹配的，
之後再右移一位，匹配的是nan最先匹配的序列是n,這是可以匹配的。

如果我們事Crowdsourced Security Testing道pattern本身的這些資訊就不用每次匹配失敗後都把target_index回退回去，
這種回退就浪費了很多不必要的時間，如果能事先計算出pattern本身的這些性質，
那麼就可以在失配時直接把pattern移動到下一個可能的位置，
把其中根本不可能匹配的過程省略掉，
如上表所示我們在index=2時失配，此時就可以直接把pattern移動到index=4的狀態，
kmp演算法就是從此出發。

 

二、KMP演算法

1、 覆蓋函數(overlay_function)

覆蓋函數所表徵的是pattern本身的性質，可以讓為其表徵的是pattern從左開始的所有連續子串的自我覆蓋程度。
比如如下的字串，abaabcaba

由於計數是從0始的，因此覆蓋函數的值為0說明有1個匹配，對於從0還是從來開始計數是偏好問題，

具體請自行調整，其中-1表示沒有覆蓋，那麼何為覆蓋呢，下面比較數學的來看一下定義，比如對於序列

a0a1...aj-1 aj

 

要找到一個k,使它滿足

a0a1...ak-1ak=aj-kaj-k+1...aj-1aj

而沒有更大的k滿足這個條件，就是說要找到儘可能大k,使pattern前k字元與後k字元相匹配，k要儘可能的大，
原因是如果有比較大的k存在，而我們選擇較小的滿足條件的k，
那麼當失配時，我們就會使pattern向右移動的位置變大，而較少的移動位置是存在匹配的，這樣我們就會把可能匹配的結果丟失。

比如下面的序列，

在紅色部分失配，正確的結果是k=1的情況，把pattern右移4位，如果選擇k=0,右移5位則會產生錯誤。
計算這個overlay函數的方法可以採用遞推，可以想象如果對於pattern的前j個字元，如果覆蓋函數值為k

a0a1...ak-1ak=aj-kaj-k+1...aj-1aj
則對於pattern的前j+1序列字元，則有如下可能
⑴     pattern[k+1]==pattern[j+1] 此時overlay(j+1)=k+1=overlay(j)+1
⑵     pattern[k+1]≠pattern[j+1] 此時只能在pattern前k+1個子符組所的子串中找到相應的overlay函數，h=overlay(k),如果此時pattern[h+1]==pattern[j+1],則overlay(j+1)=h+1否則重複(2)過程.

 

下面給出一段計算覆蓋函數的代碼：

#include<iostream>
#include<string>
using namespace std;
void compute_overlay(const string& pattern)
{
    const int pattern_length = pattern.size();
    int *overlay_function = new int[pattern_length];
    int index;
    overlay_function[0] = -1;
    for(int i=1;i<pattern_length;++i)
    {
        index = overlay_function[i-1];
        //store previous fail position k to index;
       
        while(index>=0 && pattern[i]!=pattern[index+1])
        {
            index = overlay_function[index];
        }
        if(pattern[i]==pattern[index+1])
        {
            overlay_function[i] = index + 1; 
        }
        else
        {
            overlay_function[i] = -1;
        }
    }
    for(i=0;i<pattern_length;++i)
    {
        cout<<overlay_function[i]<<endl;
    }
    delete[] overlay_function;
}
int main()
{
    string pattern = "abaabcaba";
    compute_overlay(pattern);
    return 0;
}

運行結果為：

-1
-1
0
0
1
-1
0
1
2
Press any key to continue

-------------------------------------

 

2、kmp演算法
     有了覆蓋函數，那麼實現kmp演算法就是很簡單的了，我們的原則還是從左向右匹配，但是當失配發生時，我們不用把target_index向回移動，target_index前面已經匹配過的部分在pattern自身就能體現出來，只要動pattern_index就可以了。

當發生在j長度失配時，只要把pattern向右移動j-overlay(j)長度就可以了。

 如果失配時pattern_index==0，相當於pattern第一個字元就不匹配，
這時就應該把target_index加1，向右移動1位就可以了。

 

ok，就是KMP演算法的過程（紅色即是採用KMP演算法的執行過程）：

 

KMP 演算法可在O（n+m）時間內完成全部的串的模式比對工作。

ok，最後給出KMP演算法實現的c++代碼：

#include<iostream>
#include<string>
#include<vector>
using namespace std;

int kmp_find(const string& target,const string& pattern)
{
    const int target_length = target.size();
    const int pattern_length = pattern.size();
    int * overlay_value = new int[pattern_length];
    overlay_value[0] = -1;
    int index = 0;
    for(int i=1;i<pattern_length;++i)
    {
        index = overlay_value[i-1];
        while(index>=0 && pattern[index+1]!=pattern[i])
        {
            index  = overlay_value[index];
        }
        if(pattern[index+1]==pattern[i])
        {
            overlay_value[i] = index +1;
        }
        else
        {
            overlay_value[i] = -1;
        }
    }
    //match algorithm start
    int pattern_index = 0;
    int target_index = 0;
    while(pattern_index<pattern_length&&target_index<target_length)
    {
        if(target[target_index]==pattern[pattern_index])
        {
            ++target_index;
            ++pattern_index;
        }
        else if(pattern_index==0)
        {
            ++target_index;
        }
        else
        {
            pattern_index = overlay_value[pattern_index-1]+1;
        }
    }
    if(pattern_index==pattern_length)
    {
        return target_index-pattern_index;
    }
    else
    {
        return -1;
    }
    delete [] overlay_value;
}

int main()
{
    string source = " annbcdanacadsannannabnna";
    string pattern = " annacanna";
    cout<<kmp_find(source,pattern)<<endl;
    return 0;
}
//運行結果為 -1.

 

三、kmp演算法的來源
    kmp如此精巧，那麼它是怎麼來的呢，為什麼要三個人合力才能想出來。其實就算沒有kmp演算法，人們在字元匹配中也能找到相同高效的演算法。這種演算法,最終相當於kmp演算法，只是這種演算法的出發點不是覆蓋函數，不是直接從匹配的內在原理出發，而使用此方法的計算的覆蓋函數過程式複雜且不易被理解，但是一但找到這個覆蓋函數，那以後使用同一pattern匹配時的效率就和kmp一樣了，其實這種演算法找到的函數不應叫做覆蓋函數，因為在尋找過程中根本沒有考慮是否覆蓋的問題。

    說了這麼半天那麼這種方法是什麼呢，這種方法是就大名鼎鼎的確定的有限自動機(Deterministic finite state automaton DFA),DFA可識別的文法是3型文法，又叫正規文法或是正則文法，既然可以識別正則文法，那麼識別確定的字串肯定不是問題(確定字串是正則式的一個子集)。對於如何構造DFA,是有一個完整的演算法，這裡不做介紹了。在識別確定的字串時使用DFA實在是大材小用，DFA可以識別更加通用的Regex，而用通用的構建DFA的方法來識別確定的字串，那這個overhead就顯得太大了。

    kmp演算法的可貴之處是從字元匹配的問題本身特點出發，巧妙使用覆蓋函數這一表徵pattern自身特點的這一概念來快速直接產生識別字串的DFA,因此對於kmp這種演算法，理解這種演算法高中數學就可以了，但是如果想從無到有設計出這種演算法是要求有比較深的數學功底的。
 

ok，完。