徹底理解AC多模式匹配算法

（本文尤其適合遍覽網上的講解而仍百思不得姐的同學） 

一、原理

AC自動機首先將模式組記錄為Trie字典樹的形式，以節點表示不同狀態，邊上標以字母表中的字符，表示狀態的轉移。根節點狀態記為0狀態，表示起始狀態。當一個狀態處有一個模式串終結則標記一下。

目前流傳較多的講解多大同小異，尤其是配圖，基本采用的是Aho和Corasiek兩位巨巨的文章efficient string matching an aid to bibliographic search里的，竊以為那張示意圖存在失配點靠前的特點（什么是失配？往下看），看起來稍稍費勁。

我找了樣例畫了一套新圖，主要目標是通過稍微的誇張（失配點遠離）讓過程更清晰。

匹配的過程是：從0狀態起點開始，以字符流輸入，進行適當的狀態轉移，如果可以抵達某一標記終結的狀態，則成功匹配模式，串值為從0到終結點的路徑。

按照傳統的說法，狀態機有三個主要函數支撐：goto（狀態正常轉移），fail（狀態失配轉移），output（傳回匹配結果），而我認為與其規定是具體的函數，倒不如說是三個功能的模塊，有不同於函數的實現形式。

 

Trie樹的建立是簡單的，在此基礎上我們要完善更多的數據結構，實現goto的功能。

goto是自動機基本的狀態轉移過程，很好想，就是在建立Trie樹時讓每個狀態維護一組指針（廣義的），使得在每一狀態對於輸入都可以正確轉移，沒有對應的則報錯（現在回答剛才的問題，什么是失配？失配就是一個狀態接受了無法轉移的字符，記fail）。除了字典樹中的樹枝以外，還有一個轉移就是在開始節點，對於不能流進自動機的字符，不報錯而是再一次轉到開始節點（如上圖示），很好理解，對於待匹配串λthis，λ為不含t，h的任意串，真正的模式匹配是在去除了它以后開始的。（當然還有其他的用意，坑稍后填）

 

好了，正常的狀態流轉已經建立好了，現在看失配時我們的狀態流何去何從。舉一個栗子，如果輸入thip這個串，狀態的流轉應該如下圖：

那3狀態處報錯后應該怎么處理呢？最好想的方法當然是錯開一位，再從頭開始匹配（這種方法就像一位老人家曾經說過，太年輕太簡單，有時還很幼稚），AC二位的辦法是——利用圖中的關系計算出一套跳轉關系——在x點處失配的串不打回開頭來過，而是跳到y點——繼續匹配當前字符。這套規則叫做失配函數，也就是fail功能模塊。要點在於當前字符不向前回溯，想想着很適合字符流的關鍵字匹配對不對。

好了，告訴大家3狀態的失配跳轉在6狀態，先不用管怎么得到的，想想這個過程：3得到p字符，失配，憑goto無法轉移狀態，使用失配時通用的fail，狀態跳至6，接受p——還是這個字符，成功匹配到終結狀態7。單趟遍歷目標串，cool。

當然這套規則是需要小心計算的。采用的方法很巧妙，在樹形結構中很像廣度優先搜索BFS，數學形式又很像動態規划DP。

正式開始之前請認真思考這個情況：已知2狀態的失配跳轉為5，怎么求3狀態的失配跳轉？從圖中很容易看出，2通過i流向3，而5恰有對i的goto，自然地，3失配時可以跳轉至6，噠噠

現在我把圖小小地改動一下，把hip變成hop，我們都喜歡hip-hop~：

 

2的失配跳轉仍然是5，然而對於所有使2不失配的字符，5都沒有合適的goto——即會在5也失配，此種情況怎么求3的失配跳轉？

請仔細讀這兩句話：

2的失配跳轉說明不能采用前綴th

5的失配跳轉說明不能采用前綴h（現在不要想2的事情了，單獨想5）

——失配跳轉實際上是一個逐字符推后匹配模式前綴的過程

 那么既然h開頭的也不能匹配模式了，那么對於目標串，要從i開始匹配了——下一次狀態就是5的失配跳轉0！

這是一個向前遞歸的過程，而前面提到0的大量無匹配字符均指回0自己則巧妙地保證了這個遞歸會最不濟也在會0處停下：這種時候則是放棄之前的全部前綴從當前字符重新開始嘗試匹配了，對吧。

我要強調，失配跳轉的過程中當前字符是不變的。

至此，我們也完整的構造了fail模塊的規則。

output需要做的則是對匹配路徑上的每一狀態，檢查是否為一個模式的終結，如果是，用一種合適的方式傳回這個匹配的結果。

Another question！目標串全部模式匹配：在匹配到一個模式后，應當驅動自動機繼續無遺漏地匹配下一個出現的模式（這個下一模式也許會和已匹配的部分或全部重疊），我再次重復這句話，失配跳轉實際上是一個逐字符推后匹配模式前綴的過程，那么應該很簡單了吧，匹配到一個模式后自然一次失配跳轉就行了！自動機會把前綴去掉一個字符繼續匹配。

 

二、關於自動機的數據結構表示

我在原理中避開一個一定要解釋清楚的問題，就是自動機的數據結構實現。Aho & Corasiek的論文中稱為goto/fail/output function,與其理解為函數倒不如說是功能，因為它們的實現不必是有輸入輸出的函數，而可以是向更直接的數據結構直接查詢。

我實踐中認為易於實現的寫法：goto功能就可以實現在結點結構中，每個狀態維護一個轉向結點的指針，無效則置空；fail即可以是一張自動機維護的表；output在結點中標記是否終結，如果終結，狀態結點存儲模式串，檢測到終結直接傳回。

 

三、完整代碼

#include <cstdlib>
#include <set>
#include <string>
#include <vector>
#include <queue>
#include <iostream>

using namespace std;

#define ALPHABET_NUMBER 26

struct StateNode
{
    bool finish_{ false };
    int state_{ 0 };
    string pattern_{};
    //goto table
    vector<StateNode *> transition_table_{ vector<StateNode *>(ALPHABET_NUMBER) };
};

class ACSM
{
private:
    StateNode *start_node_;
    int state_count_;
    vector<StateNode *> corresponding_node_;
    vector<StateNode *> fail_;
public:
    ACSM() :start_node_{ new StateNode() }, state_count_{ 0 }
    {
        //state0 is start_node_
        corresponding_node_.push_back(start_node_);
    }
    //read all patterns and produce the goto table
    void load_pattern(const vector<string> &_Patterns)
    {
        int latest_state = 1;
        for (const auto &pattern : _Patterns)
        {
            auto *p = start_node_;
            for (int i = 0; i < pattern.size(); ++i)
            {
                auto *next_node = p->transition_table_[pattern[i] - 'a'];
                if (next_node == nullptr)
                {
                    next_node = new StateNode();
                }
                if (next_node->state_ == 0)
                {
                    next_node->state_ = latest_state++;
                    //update the table
                    corresponding_node_.push_back(next_node);
                }
                //the goto table
                p->transition_table_[pattern[i] - 'a'] = next_node;
                p = next_node;
            }
            p->finish_ = true;
            p->pattern_ = pattern;
        }
        for (int i = 0; i < ALPHABET_NUMBER; ++i)
        {
            if (start_node_->transition_table_[i] == nullptr)
            {
                start_node_->transition_table_[i] = start_node_;
            }
        }
        state_count_ = latest_state;
    }
    //produce fail function
    void dispose()
    {
        queue<StateNode *> q;
        fail_ = std::move(vector<StateNode *>(state_count_));
        for (const auto nxt : start_node_->transition_table_)
        {
            //d=1,f=0
            if (nxt->state_ != 0)
            {
                fail_[nxt->state_] = start_node_;
                q.push(nxt);
            }
        }
        //calculate all fail redirection
        while (!q.empty())
        {
            auto known = q.front();
            q.pop();
            for (int i = 0; i < ALPHABET_NUMBER; ++i)
            {
                auto nxt = known->transition_table_[i];
                if (nxt && nxt->state_ != 0)
                {
                    auto p = fail_[known->state_];
                    while (!p->transition_table_[i])
                    {
                        p = fail_[p->state_];
                    }
                    fail_[nxt->state_] = p->transition_table_[i];
                    q.push(nxt);
                }
            }
        }
    }
    //search matching
    void match(const string &_Str, set<string> &_S)
    {
        auto p = start_node_;
        for (int i = 0; i < _Str.size(); ++i)
        {
            int trans = _Str[i] - 'a';
            p =
                p->transition_table_[trans]
                ? p->transition_table_[trans]
                : (--i, fail_[p->state_]);
            if (p->finish_)
            {
                _S.insert(p->pattern_);
            }
        }
    }
};

int main()
{
    ACSM acsm;
    vector<string> patterns{ "his","hers","she","he" };
    set<string> matched;
    acsm.load_pattern(patterns);
    acsm.dispose();
    string str{ "hishers" };
    acsm.match(str, matched);
    for (const auto str : matched)cout << str << endl;
    system("pause");
    return 0;
}

 

謝謝閱讀