Aho-Corasick automaton（AC自動機）解析及其在算法競賽中的典型應用舉例

摘要：

　　本文主要講述了AC自動機的基本思想和實現原理，如何構造AC自動機，着重講解AC自動機在算法競賽中的一些典型應用。

• 什么是AC自動機？
• 如何構造一個AC自動機？
• AC自動機在算法競賽中的典型應用有哪些？
• 例題解析

---

什么是AC自動機？

　　什么是AC自動機，不是自動AC的機器（想的美），而是一種多模匹配算法，英文名稱Aho-Corasick automaton（前面的一串據說是一位科學家的名字），於1975年誕生於貝爾實驗室。

　　回憶之前的KMP算法解決的一類問題是給出一個模板和一個文本串，問這一個模板在該文本串中的存在情況（包括是否存在、存在幾次、哪些位置等等）。現在如果是多個模板呢？可能你會想到一個一個拿出來用KMP算法進行匹配，但是如果文本串很長，模板又很多的話，KMP算法就不適合了(不滿足於能解決問題，而追求又快又好的解決問題是算法研究的源動力)。而AC自動機正是為了解決這類問題而生的。

　　基本思想

　　不得不重提的是KMP算法之所以能夠在高效的處理單模匹配問題，主要得益於next數組的建立，能夠使匹配的狀態在線性的字符串上進行轉移，使得失配后副串能夠盡可能的“滑的遠一些“。而AC自動機也有類似功能的工具那就是fail指針。

　　應該能想到的是單模匹配的KMP算法的狀態轉移圖是線性的字符串加上失配邊組成的，那么多模匹配的AC自動機算法的狀態轉移圖是字典樹加上失配邊組成的。

　　為了說明實際問題，直接看一個例子如下：

　　

　　問題很明確，我們需要只遍歷一遍文本串就找出所有單詞表中存在的單詞（只遍歷一遍的想法和KMP算法有異曲同工之妙）。

　　我們先根據字符集合{she,he,say,shr,her}建立字典樹如上圖所示，然后我們拿着yasherhs去匹配，發現前兩個字符無法匹配，跳過，第三個字符開始，she可以匹配，記錄下來，繼續往后走發現沒有匹配了，結果就是該文本串只存在一個單詞，很明顯，答案是錯的，因為存在she、he、her三個單詞。

　　可以發現的是使用文本串在字典樹上進行匹配的時候，找到了一個單詞結點后還應該看看有沒有以該單詞結點的后綴為前綴的其他單詞，比如she的后綴he是單詞he和her的前綴。因此就需要一個fail指針在發現失配的時候指向其他存在e的結點，來“安排”之后應該怎么辦。

　　總的來說，AC自動機中fail指針和KMP中next數組的作用是一致的，就是要想在只遍歷一遍文本串的前提下，找到全部匹配模板，就必須安排好匹配過程中失配后怎么辦。具體如何安排就是怎么在字典樹上加失配邊的問題了（也即如何構造一個AC自動機）。

如何構造一個AC自動機？

　　字典樹之前已經學過了（需要回顧的請點這里），關鍵是怎么加失配邊。規則如下：

• 根結點的fail指針為空（或者它自己）；
• 直接和根結點相連的結點，如果這些結點失配，就只能重新開始匹配，故它們的fail指針指向根結點；
• 其他結點，設當前結點為father,其孩子結點為child。要尋找child的fail指針，需要看father的fail指針指向的結點，假設是tmp,要看tmp的孩子中有沒有和child所代表的字符相同的，有則child的fail指針指向tmp的這個孩子結點，沒有則繼續沿着tmp的fail指針往上走，如果找到相同，就指向，如果一直找到了根結點的fail也就是空的時候，child的fail指針就指向root，表示重新從根結點開始匹配。

　　其中考察father的fail指針指向的結點 有沒有和child相同的結點，包括繼續往上，就保證了前綴是相同的，比如剛才尋找右側h的孩子結點e的fail指針時，找到右側h的fail指針指向左側的h結點，他的孩子中有e，就將右側h的孩子e的fail指針指向它就保證了前綴h是相同的。

　　這樣，就用fail指針來安排好每次失配后應該跳到哪里，而fail指針跳到哪里，說明從根結點到這個結點之前的字符串已經匹配過了，從而避免了重復匹配，也就完美的解決了只遍歷一次文本串就找出所有單詞的問題。

　 具體編程實現在字典樹上添加失配邊有兩種方法，一種是鏈表法，一種是轉移矩陣法。

　   鏈表法

　　有了上面fail指針的計算規則，利用隊列BFS順序遞推可以寫出如下代碼：

const int maxw = 10010;      //最大單詞數 
const int maxwl = 61;        //最大單詞長度 
const int maxl = 1001000;    //最大文本長度 
const int sigm_size = 26;    //字符集大小 

struct Node {
    int sum;//>0表示以該結點為前綴的單詞個數，=0表示不是單詞結點，=-1表示已經經過計數 
    Node* chld[sigm_size];
    Node* fail;
    Node() {
        sum = 0;
        memset(chld, 0, sizeof(chld));
        fail = 0;
    }
};
struct ac_automaton {
    Node* root;
    void init() {
        root = new Node;
    }    
    int idx(char c) {
        return c - 'a';
    }
    void insert(char *s) {
        Node* u = root; 
        for(int i = 0; i < s[i]; i++) {
            int c = idx(s[i]);
            if(u->chld[c] == NULL) 
                u->chld[c] = new Node;
            
            u = u->chld[c];
        }
        u->sum++;//以該串為前綴的單詞個數++ 
    }
    void getfail() {
        queue<Node*> q;
        q.push(root);//根結點的fail指針為空 
        while(!q.empty()) {
            Node* u = q.front();
            q.pop();
            for(int i = 0; i < sigm_size; i++) {                //尋找當前結點的所有非空子結點的fail指針 
                if(u->chld[i] != NULL) {
                    if(u == root)//根結點 
                        u->chld[i]->fail = root;
                    else {       //非根節點 
                        Node* tmp = u->fail;                    //找到它父親的fail指針指向的結點 
                        while(tmp != NULL) {                    //向上只有根結點的fail指針是空，所以只要不是根結點就循環 
                            if(tmp->chld[i] != NULL) {          //直到發現存在一個結點的子結點與其相同 
                                u->chld[i]->fail = tmp->chld[i];//就將它的fail指針指向該子結點然后結束循環 
                                break;
                            }
                            tmp = tmp->fail;//否則一直往上找 
                        }
                        if(tmp == NULL)     //如果尋找到根結點還沒有找到，就指向根結點，讓主串從根結點重新開始匹配 
                            u->chld[i]->fail = root;
                    }
                    q.push(u->chld[i]);     //子結點入隊 
                }
            }
        }
    }
    int query(char *t) {
        
        int cnt = 0;//文本中存在單詞的個數 
        Node* u = root; 
        for(int i = 0; t[i]; i++) {//yasherhs 
            int c = idx(t[i]);
            while(u != root && u->chld[c] == NULL)//不是根結點而且不匹配，順着fail指針走，直到可以匹配或者走到根結點 
                u = u->fail;
            
            u = u->chld[c];  //經過上面的循環，u要么是匹配結點要么是根結點，繼續往下走 
            if(u == NULL)    //如果結點為空，下一個字符重新從根結點開始 
                u = root;
            
            Node* tmp = u;
            while(tmp != root) {    //只要沒有返回到根結點，就證明在字典樹上還存在找到單詞的可能 
                if(tmp->sum > 0) {
                    cnt += tmp->sum;//單詞計數器加上以當前結點為前綴的單詞數 
                    tmp->sum = -1;  //表示該單詞結點已經計過數，防止重復計數 
                } 
                else                //該單詞結點已經匹配過了直接退出,因為后面的狀態轉移是確定的並且是走過的 
                    break;
                tmp = tmp->fail;    //往其他子樹上找 
            } 
        }
        return cnt;
    }
};

　　上面的代碼中在調用getfail方法之后就構造好了一個AC自動機，具體查詢的時候就需要在字典樹的狀態轉移圖上進行匹配了。

　　具體的匹配過程可分為兩種情況：

　　1.當前字符匹配，就沿着它的狀態轉移圖往上找，找到單詞結點就統計，直到返回到根結點，說明不存在其他單詞。

　　2.當前字符不匹配，就沿着它的fail指針往上走，直到找到匹配再進入while循環統計單詞，或者一直到不到匹配直接跳過。

　　如此兩種情況交替，直到將文本串遍歷完，也就完成了統計。

　　　

　   用上圖中的例子來說，統計yasherhs中幾個單詞表中的單詞。

　  當i=0,1時，由於Trie中沒有對應的路徑，故直接跳過；i=2,3,4時，指針u指向右下節點e。因為節點e的sum為1，所以cnt += sum，並將節點e的sum值置為-1，表示該單詞已經出現過，避免重復計數，然后tmp指向e節點的失敗指針所指向的節點左下e，發現是單詞結點cnt  += sum，最后tmp指向root，退出while循環，這個過程中cnt增加了2，表示找到了2個單詞she和he。

　  當i=5時，u上次指向的是右下e，r不匹配，u指向u的fail指針指向的結點左下e，發現匹配r，u指向左下r，進入下面的while循環，因為左下r的sum為1，所以cnt += sum，表示發現了單詞her；

　  最后當i=6,7時，找不到任何匹配，查詢過程結束（強烈建議手動模擬一下）。

　  鏈表法可以將原理實現直觀的轉化成代碼，不過更常見的是實現起來較為簡潔也更為巧妙的轉移矩陣法。

 　  轉移矩陣法

　   有了轉移矩陣建立字典樹的基礎，然后在字典樹上加失配邊，代碼如下：

struct ac_automaton {
    int ch[maxnode][sigm_size];//一個結點對應一個字符集
    int fail[maxnode];            //每個結點的fail指針
    int val[maxnode];           //每個結點的權值
    int sz; 
    
    void init() {
        sz = 0;
        newnode();               //創建一個根結點 
    }
    int newnode() {
        memset(ch[sz], -1, sizeof(ch[sz]));
        val[sz] = 0;
        return sz++;
    }
    int idx(char c) {
        return c - 'a'; 
    }
    void insert(char *s) {
        int u = 0;
        for(int i = 0; s[i]; i++) {
            int c = idx(s[i]);
            if(ch[u][c] == -1)
                ch[u][c] = newnode();
            
            u = ch[u][c];
        }
        val[u]++;
    }
    void getfail() {
        queue<int> q;
        fail[0] = 0;            //根結點的fail指針指向它自己也就是空 
        for(int i = 0; i < sigm_size; i++) {
            int u = ch[0][i];
            if(u == -1){        //根結點編號為i的結點不存在時
                ch[0][i] = 0;    //把不存在的邊補上，將其標記為0
            }
            else {                //存在時 
                fail[u] = 0;    //失配指針指向根結點並入隊 
                q.push(u);
            }
        }
        while(!q.empty()) {
            int u =q.front();
            q.pop();
            for(int i = 0; i < sigm_size; i++) { //尋找當前結點u的孩子結點的fail指針 
                int tmp = ch[u][i];
                if(tmp == -1) 
                    ch[u][i] = ch[fail[u]][i];    //把不存在的邊補上，當前結點u不存在編號為i的孩子時，
                                 //讓它指向當前結點u的fail指針指向的結點對應編號為i的孩子中存的結點編號 
                else {
                    //當前孩子結點的fail指針指向 當前結點u的fail指針指向的結點對應的孩子的編號 
                    fail[tmp] = ch[fail[u]][i];   
                    q.push(tmp);
                }
            }
        }
    }
    int query(char *t) {
        int u = 0, cnt = 0;
        for(int i = 0; t[i]; i++) {
            int c = idx(t[i]);
            u = ch[u][c];      //由於之前把邊補齊了,所以可以直接往下走，有匹配直接就是結點，沒有匹配直接是根結點 
             
            int tmp = u;
            while(tmp != 0) {  //只要不是根結點，就證明有存在繼續找到單詞的可能 
                cnt += val[tmp];
                val[tmp] = 0;
                
                tmp = fail[tmp];
            }
        }
        return cnt;
    } 
};

　　之所以說實現起來較為簡單，是因為使用了二維數組，不用指針指來指去；而說更為巧妙是因為當一個結點u不存在哪個編號為i的結點時 就填充為u的fail指針指向的結點對應編號為i的結點編號，如此一來查詢的時候就可以直接往下走，而不是需要進入一個循環找到匹配或者根結點再繼續。

　  這個是根據ACM大佬bin神的AC自動機小結中學來的，仔細體會有種DP的思想在里面。

AC自動機在算法競賽中的典型應用有哪些？

　　基本的問題是給出單詞表，給一段文本串，問單詞表中的單詞存在於文本串中的情況。

　　　　1、存在的單詞個數 HDU 2222 Keywords Search

　　　　2、輸出存在的單詞的編號 HDU 2896 病毒入侵

　　　　3、輸出存在單詞及其個數 HDU 3065 病毒持續入侵中

　　　　4、單詞重疊和不重疊的個數 ZOJ 3288 Searching the String

　   　　5、在二維矩陣中查找小的二維矩陣 UVa 11019 矩陣適配器

　　復雜的問題有和DP結合起來的，有和大數結合起來的，有和最短路結合起來的

　　　　1、修改最少次數使得文本串中不包含任何一個模板 HDU 2457 DNA repair

　　　　2、給定n個文本串，m個病毒串，文本串重疊部分可以合並，但合並后不能含有病毒串，問所有文本串合並后最短多長  HDU 3247 Resource Archiver

　　　　3、AC自動機+DP+高精度 POJ 1625 Censored!

例題解析

　　HDU 2222 Keywords Search AC自動機入門題，給出單詞表和一個文本串，問文本串中有多少個單詞表中的單詞。首先根據單詞表構建字典樹，每個單詞結點的末尾++，構造AC自動機，匹配文本串統計即可，注意不要忘了將統計過的單詞標記一下。

　　為了體會AC自動機的基本思想最好兩種構建方法都試一下。參考代碼如下：

鏈表法：

#include <cstdio>
#include <queue>
#include <cstring> 
using namespace std;

const int maxw = 10010;        //最大單詞數 
const int maxwl = 61;        //最大單詞長度 
const int maxl = 1001000;    //最大文本長度 
const int sigm_size = 26;    //字符集大小 

struct Node {
    int sum;//>0表示以該結點為前綴的單詞個數，=0表示不是單詞結點，=-1表示已經經過計數 
    Node* chld[sigm_size];
    Node* fail;
    Node() {
        sum = 0;
        memset(chld, 0, sizeof(chld));
        fail = 0;
    }
};
struct ac_automaton {
    Node* root;
    void init() {
        root = new Node;
    }    
    int idx(char c) {
        return c - 'a';
    }
    void insert(char *s) {
        Node* u = root; 
        for(int i = 0; i < s[i]; i++) {
            int c = idx(s[i]);
            if(u->chld[c] == NULL) 
                u->chld[c] = new Node;
            
            u = u->chld[c];
        }
        u->sum++;//以該串為前綴的單詞個數++ 
    }
    void getfail() {
        queue<Node*> q;
        q.push(root);//根結點的fail指針為空 
        while(!q.empty()) {
            Node* u = q.front();
            q.pop();
            for(int i = 0; i < sigm_size; i++) {                //尋找當前結點的所有非空子結點的fail指針 
                if(u->chld[i] != NULL) {
                    if(u == root)//根結點 
                        u->chld[i]->fail = root;
                    else {       //非根節點 
                        Node* tmp = u->fail;                    //找到它父親的fail指針指向的結點 
                        while(tmp != NULL) {                    //向上只有根結點的fail指針是空，所以只要不是根結點就循環 
                            if(tmp->chld[i] != NULL) {          //直到發現存在一個結點的子結點與其相同 
                                u->chld[i]->fail = tmp->chld[i];//就將它的fail指針指向該子結點然后結束循環 
                                break;
                            }
                            tmp = tmp->fail;//否則一直往上找 
                        }
                        if(tmp == NULL)     //如果尋找到根結點還沒有找到，就指向根結點，讓主串從根結點重新開始匹配 
                            u->chld[i]->fail = root;
                    }
                    q.push(u->chld[i]);     //子結點入隊 
                }
            }
        }
    }
    int query(char *t) {
        int cnt = 0;//文本中存在單詞的個數 
        Node* u = root; 
        for(int i = 0; t[i]; i++) {//yasherhs 
            int c = idx(t[i]);
            while(u != root && u->chld[c] == NULL)//不是根結點而且不匹配，順着fail指針走，直到可以匹配或者走到根結點 
                u = u->fail;
            
            u = u->chld[c]; //經過上面的循環，u要么是匹配結點要么是根結點，繼續往下走 
            if(u == NULL)    //如果結點為空，下一個字符重新從根結點開始 
                u = root;
            
            Node* tmp = u;
            while(tmp != root) {    //只要沒有返回到根結點，就證明在字典樹上還存在找到單詞的可能 
                if(tmp->sum > 0) {
                    cnt += tmp->sum;//單詞計數器加上以當前結點為前綴的單詞數 
                    tmp->sum = -1;  //表示該單詞結點已經計過數，防止重復計數 
                } 
                else                //該單詞結點已經匹配過了直接退出,因為后面的狀態轉移是確定的並且是走過的 
                    break;
                tmp = tmp->fail;    //往其他子樹上找 
            } 
        }
        return cnt;
    }
};

ac_automaton ac;
char txt[maxl];
int main() 
{
    int T,n;
    char word[maxwl];
    scanf("%d", &T);
    while(T--) {
        ac.init();
        scanf("%d", &n);
        for(int i = 0; i < n; i++) {
            scanf("%s", word);
            ac.insert(word);
        }
        ac.getfail();
        
        scanf("%s", txt);
        printf("%d\n", ac.query(txt));
    }
    return 0;
} 

轉移矩陣法：

#include <cstdio>
#include <cstring> 
#include <queue>
using namespace std;

const int maxwl = 61;
const int maxw = 10010;
const int maxl = 1001000;
const int sigm_size = 26;
const int maxnode = maxw * maxwl;

struct ac_automaton {
    int ch[maxnode][sigm_size];//一個結點對應一個字符集
    int fail[maxnode];            //每個結點的fail指針
    int val[maxnode];           //每個結點的權值
    int root, sz; 
    
    void init() {
        sz = 0;
        root = newnode();               //創建一個根結點 
    }
    int newnode() {
        memset(ch[sz], -1, sizeof(ch[sz]));
        val[sz] = 0;
        return sz++;
    }
    int idx(char c) {
        return c - 'a'; 
    }
    void insert(char *s) {
        int u = root;
        for(int i = 0; s[i]; i++) {
            int c = idx(s[i]);
            if(ch[u][c] == -1)
                ch[u][c] = newnode();
            
            u = ch[u][c];
        }
        val[u]++;
    }
    void getfail() {
        queue<int> q;
        fail[root] = root;            //根結點的fail指針指向它自己也就是空 
        for(int i = 0; i < sigm_size; i++) {
            int u = ch[root][i];
            if(u == -1){        //根結點編號為i的結點不存在時
                ch[root][i] = root;    //把不存在的邊補上，將其標記為0
            }
            else {                //存在時 
                fail[u] = root;    //失配指針指向根結點並入隊 
                q.push(u);
            }
        }
        while(!q.empty()) {
            int u =q.front();
            q.pop();
            for(int i = 0; i < sigm_size; i++) { //尋找當前結點u的孩子結點的fail指針 
                int tmp = ch[u][i];
                if(tmp == -1) 
                    ch[u][i] = ch[fail[u]][i];    //把不存在的邊補上，當前結點u不存在編號為i的孩子時，
                                                //讓它指向當前結點u的fail指針指向的結點對應編號為i的孩子中存的結點編號 
                else {
                    //當前孩子結點的fail指針指向 當前結點u的fail指針指向的結點對應的孩子的編號 
                    fail[tmp] = ch[fail[u]][i];   
                    q.push(tmp);
                }
            }
        }
    }
    int query(char *t) {
        int u = root, cnt = 0;
        for(int i = 0; t[i]; i++) {
            int c = idx(t[i]);
            u = ch[u][c];      //由於之前把邊補齊了,所以可以直接往下走，有匹配直接就是結點，沒有匹配直接是根結點 
             
            int tmp = u;
            while(tmp != 0) { //只要不是根結點，就證明有存在繼續找到單詞的可能 
                cnt += val[tmp];
                val[tmp] = 0;
                
                tmp = fail[tmp];
            }
        }
        return cnt;
    } 
};

ac_automaton ac; 
char txt[maxl];
int main() 
{
    int n, m;
    char word[maxwl];
    scanf("%d", &n);
    while(n--) {
        scanf("%d", &m);
        ac.init();
        for(int i = 0; i < m; i++) {
            scanf("%s", word);
            ac.insert(word);
        }
        ac.getfail();
        
        scanf("%s", txt);
        printf("%d\n", ac.query(txt));
    }
    return 0;
} 

　　HDU 2896 病毒侵襲 給出病毒和多個文本串，輸出每個文本串中存在病毒的編號。

　　想到怎么記錄編號和注意輸出格式就沒什么大問題。需要知道的是ASCII可見字符是32到126，共95個可見字符。參考代碼如下（鏈表法，請使用C++提交，G++結果MLE,可能G++和C++的內存分配機制不同）：

#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
#include <algorithm> 
using namespace std;

const int maxwl = 210;
const int maxl = 10010;
const int sigm_size = 128 - 33;

struct Node {
    int num;
    Node* fail;
    Node* chld[sigm_size];
    Node() {
        num = 0; 
        fail = 0;
        memset(chld, 0, sizeof(chld));
    }
};
struct ac_automaton {
    Node* root;
    void init() { 
        root = new Node;
    }
    int idx(char c) {
        return c - 32;
    }
    void insert(char *s, int v) {
        Node* u = root;
        for(int i = 0; s[i]; i++) {
            int c = idx(s[i]);
            if(u->chld[c] == NULL)
                u->chld[c] = new Node;
            
            u = u->chld[c];
        }
        u->num = v;
    }
    void getfail() {
        queue<Node*> q;
        q.push(root);
        while(!q.empty()) {
            Node* u = q.front();
            q.pop();
            for(int i = 0; i < sigm_size; i++) {
                if(u->chld[i] != NULL) {
                    if(u == root)
                        u->chld[i]->fail = root;
                    else {
                        Node* tmp = u->fail;
                        while(tmp != NULL) {
                            if(tmp->chld[i] != NULL) {
                                u->chld[i]->fail = tmp->chld[i];
                                break;
                            }
                            tmp = tmp->fail;
                        }
                        if(tmp == NULL)
                            u->chld[i]->fail = root;
                    }
                    q.push(u->chld[i]); 
                }
            } 
        }
    }
    void query(char *t, vector<int> &p) {
        Node* u = root;
        for(int i = 0; t[i]; i++) {
            int c = idx(t[i]);
            while(u != root && u->chld[c] == NULL)
                u = u->fail;
                
            u = u->chld[c];
            if(u == NULL)
                u = root;
            
            Node* tmp = u;
            while(tmp != root) {
                if(tmp->num > 0) 
                    p.push_back(tmp->num);//記錄存在的病毒編號 
                
                tmp = tmp->fail;
            }
        }
    }
}ac;

int main()
{
    int n, m;
    char word[maxwl], txt[maxl];
    while(scanf("%d", &n) != EOF) {
        ac.init();
        for(int i = 0; i < n; i++) {
            scanf("%s", word);
            ac.insert(word, i+1);
        }
        ac.getfail(); 
        
        scanf("%d", &m);
        int tot = 0;
        for(int i = 0; i < m; i++) {
            scanf("%s", txt);
            vector<int> p;
            ac.query(txt, p);
            if(!p.empty()) {
                sort(p.begin(), p.end());
                printf("web %d:",i+1);
                for(int i = 0; i < p.size(); i++) 
                    printf(" %d", p[i]);
                puts("");
                tot++;
            }
        }
        printf("total: %d\n", tot);
    }
    return 0;
}

　　HDU 3065 病毒侵襲持續中 給出病毒和文本串，輸出每個病毒及其存在的次數。

　　和上一題很像，注意使用鏈表法寫的時候多樣例要釋放內存，否則可能會超內存，但是轉移矩陣就不會，因此優先選擇轉移矩陣實現。鏈表法參考如下（如何遞歸釋放內存）：

#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;

const int maxw = 1010;
const int maxwl = 61;
const int maxl = 2000010;
const int sigm_size = 128 -33;

char words[maxw][maxwl];
char txt[maxl];

struct Node {
    int flag;
    Node* fail;
    Node* chld[sigm_size];
    Node() {
        flag = 0;
        fail = 0;
        memset(chld, 0, sizeof(chld));
    }
};
struct ac_automaton {
    Node* root;
    int num[maxw];
    void init() {
        root = new Node;
    }
    int idx(char c) {
        return c - 32;
    }
    void insert(char *s, int v) {
        Node* u = root;
        for(int i = 0; s[i]; i++) {
            int c = idx(s[i]);
            if(u->chld[c] == NULL)
                u->chld[c] = new Node;
            u = u->chld[c];
        }
        u->flag = v;
    }
    void getfail() {
        queue<Node*> q;
        q.push(root);
        while(!q.empty()) {
            Node* u = q.front();
            q.pop();
            for(int i = 0; i < sigm_size; i++) {
                if(u->chld[i] != NULL) {
                    if(u == root)
                        u->chld[i]->fail = root;
                    else {
                        Node* tmp = u->fail;
                        while(tmp != NULL) {
                            if(tmp->chld[i] != NULL) {
                                u->chld[i]->fail = tmp->chld[i];
                                break;
                            }
                            tmp = tmp->fail;
                        }
                        if(tmp == NULL)
                            u->chld[i]->fail = root;
                    }    
                    q.push(u->chld[i]);
                }
            }
        }
    }
    void query(char *t, int n) {
        Node* u = root;
        memset(num, 0, sizeof(num));
        for(int i = 0; t[i]; i++) {
            int c = idx(t[i]);
            while(u != root && u->chld[c] == NULL)
                u = u->fail;
            
            u = u->chld[c];
            if(u == NULL)
                u = root;
                
            Node* tmp = u;
            while(tmp != root) {
                if(tmp->flag > 0)
                    num[tmp->flag]++;
                
                tmp = tmp->fail;
            }
        }
        for(int i = 1; i <= n; i++) {
            if(num[i] > 0)
                printf("%s: %d\n", words[i], num[i]);
        }
    }
    void freenode(Node* u) {
        if(u == NULL)
            return;
        for(int i = 0; i < sigm_size; i++) 
            freenode(u->chld[i]);
        delete u;
    }
}ac;

int main() 
{
    int n;
    char word[maxwl];
    while(scanf("%d", &n) != EOF) {
        ac.init();
        for(int i = 1; i <= n; i++) {
            scanf("%s", words[i]);
            ac.insert(words[i], i);
        }
        ac.getfail();
        
        scanf("%s", txt);
        ac.query(txt, n);
        ac.freenode(ac.root);//多樣例測試時別忘記釋放內存 
    }
    return 0;
}

　　ZOJ 3228 Searching the String 先給出文本串，再給出多個單詞，但詢問方式不同，0表示可以重疊存在的次數，1表示不可重疊存在的次數。

　　重疊的詢問好求，一遍AC自動機解決，關鍵是不可重疊次數。設想，如果我們能夠記錄一個單詞上一次在文本串中的匹配位置，那么當前單詞結點的末尾在文本串中的位置 - 當前單詞結點在文本串中上一次匹配的位置  大於等於以當前字符結尾的單詞結點的長度時，表示不重疊。可以使用一個二維數組記錄每個單詞兩種詢問的答案，最后查詢輸出。參考代碼如下：

#include <cstdio>
#include <queue>
#include <cstring> 
using namespace std;

const int sigm_size = 26;                //字符集的大小 
const int maxl = 100010;                //文本串的長度 
const int maxw = 10010;                    //單詞個數 
const int maxwl = 7;                    //單詞長度 
const int maxnode = maxw * maxwl * 10;    //字典樹結點數 = 單詞數乘以單詞長度乘以10 

char txt[maxl];
int node[maxl];                        //記錄每個單詞在字典樹中單詞結點的編號 
int op[maxl];                        //每個單詞的查詢方式
                         
struct ac_automaton {
    int ch[maxnode][sigm_size], fail[maxnode];
    int pos[maxnode];    //記錄以當前字符結尾的單詞的長度 
    int L, root;
    void init() {
        L = 0;
        root = newnode();
    } 
    int newnode() {
        memset(ch[L], -1, sizeof(ch[L]));
        pos[L++] = 0;    //以當前字符結尾的單詞長度為0 
        return L-1; 
    }
    int idx(char c) {
        return c - 'a';
    }
    void insert(char *s, int v) {
        int now = root;
        for(int i = 0; s[i]; i++) {
            int c = idx(s[i]);
            if(ch[now][c] == -1)
                ch[now][c] = newnode();
            now = ch[now][c];
            pos[now] = i+1;//以當前字符結尾的單詞的長度 
        }
        node[v] = now;//編號為v的模式串在字典樹中的序號 
    } 
    void getfail() {
        queue<int> q;
        fail[root] = root;
        for(int i = 0; i < sigm_size; i++) {
            if(ch[root][i] == -1)
                ch[root][i] = root;
            else {
                fail[ch[root][i]] = root;
                q.push(ch[root][i]);
            }
        }
        while(!q.empty()) {
            int now = q.front();
            q.pop();
            for(int i = 0; i < sigm_size; i++) {
                if(ch[now][i] == -1) 
                    ch[now][i] = ch[fail[now]][i];
                else {
                    fail[ch[now][i]] = ch[fail[now]][i];
                    q.push(ch[now][i]);
                }
            }
        } 
    }
    int ans[maxnode][2];                //標號為i的單詞的重疊和不重疊的個數 
    int last[maxnode];                    //記錄當前單詞結點在文本串中的上一個匹配位置
    void query(char *t) {
        memset(last, -1, sizeof(last));
        memset(ans, 0, sizeof(ans));
        int now = root;
        for(int i = 0; t[i]; i++) {
            int c = idx(t[i]);
            now = ch[now][c];
            int tmp = now;
            while(tmp != root) {
                ans[tmp][0] ++;
                /*
                    當前字符的位置 - 當前單詞結點在文本串中上一次匹配的位置 
                    大於等於以當前字符結尾的單詞結點的長度時，表示不重疊 
                */ 
                if(i - last[tmp] >= pos[tmp]) { 
                    ans[tmp][1] ++;
                    last[tmp] = i;//記錄當前單詞結點在文本串中的位置 
                }
                tmp = fail[tmp];
            }
        } 
    }
}ac;

int main() 
{
    int n, kase = 1;
    char word[maxwl];
    while(scanf("%s", txt) != EOF) {
        scanf("%d", &n);
        ac.init();
        for(int i = 0; i < n; i++) {
            scanf("%d%s", &op[i], word);
            ac.insert(word, i); 
        }
        ac.getfail();
        ac.query(txt);
        
        printf("Case %d\n", kase++);
        for(int i = 0; i < n; i++) {
            printf("%d\n", ac.ans[node[i]][op[i]]);
        }
        puts("");
    }    
    return 0;
}

　　UVA 11019 Matrix Matcher AC自動機應用的二維推廣。給出一個大的二維字符矩陣T，一個小的二維矩陣P，問P在T中存在的次數。

　　思路很簡單，使用一個二維矩陣cnt，如果cnt[r][c]表示T中以（r，c）為左上角、與P等大的矩形有多少個完整的行和P對應位置的行完全相同。當P的第j行出現在T的第r行、起始列號為i時，意味着cnt[r-j+1][i-y+2]++，其中具體加幾和存儲的起始位置有關，按照自己的規則即可。所有匹配結束后，那些cnt[r][c] == x（P的行數）的點就是一個二維匹配點。

　　另外需要注意的是P中可能存在重復，存在重復的模板會導致字典樹中結點編號覆蓋，所以使用一個vector數組保存所有的編號。參考代碼如下：

#include <vector>
#include <cstdio>
#include <queue>
#include <cstring> 
using namespace std;

const int maxn = 1100;
const int maxw = 110;
const int maxwl = 110;
const int maxnode = maxw * maxwl;
const int sigm_size = 26;

struct ac_automaton {
    int cnt[maxn][maxn];
    int ch[maxnode][sigm_size];
    int fail[maxnode];
    vector<int> val[maxnode];  
    int sz, root;
    
    void init() {
        sz = 0;
        root = newnode();
        memset(cnt, 0, sizeof(cnt));
    }
    int newnode() {
        memset(ch[sz], -1, sizeof(ch[sz]));
        val[sz].clear();
        return sz++;
    }
    int idx(char c) {
        return c - 'a';
    }
    void insert(char *s, int v) {
        int u = root;
        for(int i = 0; s[i]; i++) {
            int c = idx(s[i]);
            if(ch[u][c] == -1)
                ch[u][c] = newnode();
            
            u = ch[u][c];
        }
        val[u].push_back(v);//以該結點為末尾的p的行編號 
    }
    void getfail() {
        queue<int> q;
        fail[root] = root;
        for(int i = 0; i < sigm_size; i++) {
            if(ch[root][i] == -1)
                ch[root][i] = root;
            else {
                fail[ch[root][i]] = root;
                q.push(ch[root][i]);
            }
        }
        while(!q.empty()) {
            int u = q.front();
            q.pop();
            for(int i = 0; i < sigm_size; i++) {
                if(ch[u][i] == -1) 
                    ch[u][i] = ch[fail[u]][i];
                else {
                    fail[ch[u][i]] = ch[fail[u]][i];
                    q.push(ch[u][i]);
                }
            }
        }
    }
    void query(char *t, int r, int y) {
        int u = root;
        for(int i = 0; t[i]; i++) {
            int c = idx(t[i]);
            u = ch[u][c];//走到u結點 
            
            for(int k = 0; k < val[u].size(); k ++){//遍歷以該結點為結尾的p的每一個行編號 
                int j = val[u][k];
                //如果當前行T的第r行 - P的第j行 + 1 > 0,也就是在左上(1,1)到右下(n,m)這個區域內 
                if(r-j+1>0) cnt[r-j+1][i-y+2]++;
                //其中+1或者+2是數據存儲問題引起，二維數組從第1行第0列開始 
            }    
        }
    }
    int count(int n, int m, int x) {
        int ans = 0;
        for(int i = 1; i <= n ; i++) {
            for(int j = 1; j <= m; j++) {
                if(cnt[i][j] == x)
                    ans ++;
            }
        }
        return ans;
    }
}ac;

char t[maxn][maxn], p[maxn/10][maxn/10];
int n, m, x, y;

int main()
{
    int T;
    scanf("%d", &T);
    while(T--) {
        scanf("%d%d", &n, &m);
        for(int i = 1; i <= n; i++) {
            scanf("%s", t[i]);
        }
        ac.init();
        scanf("%d%d", &x, &y);
        for(int i = 1; i <= x; i++) {
            scanf("%s", p[i]);
            ac.insert(p[i], i);
        }
        ac.getfail();
        for(int i = 1; i <= n; i++) 
            ac.query(t[i], i, y);
        printf("%d\n", ac.count(n,m,x));
    }
    return 0;
} 

　　POJ 3691 DNA repair 給出單詞表和一個文本串，問最少修改幾個字符使得該文本串不包含所有的單詞。

　　先根據單詞表構建一個AC自動機，具體匹配的時候我們可以定義一個狀態dp[i][j]表示長度為i、以字典樹中j號結點結尾的字符串不包含所有單詞所需的最少修改次數。很容易遞推發現，dp[i+1][u]也就是長度為1+1、以當前結點結尾的字符串的最小修改次數等於 u的所有孩子結點ch[j][k]是否和當前s[i]相等的最小值。參考代碼如下：

#include <cstdio>
#include <queue>
#include <algorithm>
#include <cstring>
using namespace std;

const int inf = 0x3f3f3f3f;
const int maxw = 60;
const int maxwl = 30;
const int maxl = 1100;
const int maxnode = maxw * maxwl;
const int sigm_size = 4;

struct ac_automaton {
    int ch[maxnode][sigm_size];
    int fail[maxnode];
    bool val[maxnode];
    int root, sz;
    
    void init() {
        sz = 0;
        root = newnode();
    }
    int newnode() {
        memset(ch[sz], -1, sizeof(ch[sz]));
        val[sz] = false;
        return sz++;
    }
    int idx(char c) {
        if(c == 'A')
            return 0;
        if(c == 'C')
            return 1;
        if(c == 'G')
            return 2;
        if(c == 'T')
            return 3;
    }
    void insert(char *s) {
        int u = root;
        for(int i = 0; s[i]; i++) {
            int c = idx(s[i]);
            if(ch[u][c] == -1)
                ch[u][c] = newnode();
            u = ch[u][c];
        }
        val[u] = true;
    }
    void getfail() {
        queue<int> q;
        fail[root] = root;
        for(int i = 0; i < sigm_size; i++) {
            if(ch[root][i] == -1)
                ch[root][i] = root;
            else {
                fail[ch[root][i]] = root;
                q.push(ch[root][i]);
            }
        }
        while(!q.empty()) {
            int u = q.front();
            q.pop();
            if(val[fail[u]]) val[u] = true;
            
            for(int i = 0; i < sigm_size; i++) {
                if(ch[u][i] == -1) 
                    ch[u][i] = ch[fail[u]][i];
                else {
                    fail[ch[u][i]] = ch[fail[u]][i];
                    q.push(ch[u][i]);
                }
            }
        }
    }
    
    int dp[maxnode][maxnode];
    //定義狀態dp[i][j]表示長度為i、以字典樹上結點編號為j的字符結尾的字符串 所需的最小修改次數 
    int solve(char *s) {
        int len = strlen(s);
        for(int i = 0; i <= len; i ++) {//初始化大小為len * sz大小的空間 
            for(int j = 0; j < sz; j++) {
                dp[i][j] = inf;
            }
        }
        dp[0][root] = 0;//初始化長度為0，以根結點結尾的字符串 所需最小修改次數為 0 
        for(int i = 0; i <= len; i++) {
            for(int j = 0; j < sz; j++) {
                //之前一次拓展沒有更新表示該長度以j結尾的字符串存在病毒結點，故直接跳過 
                if(dp[i][j] >= inf) continue;
                
                    for(int k = 0; k < 4; k++) {
                        int u = ch[j][k];
                        if(val[u]) continue;//當前結點j的孩子中有的是病毒結點直接跳過 
                        int tmp;
                        if(k == idx(s[i]))
                            tmp = dp[i][j];
                        else
                            tmp = dp[i][j] + 1;
                        //更新長度加一、以孩子結點u結尾的的狀態 
                        dp[i+1][u] = min(dp[i+1][u], tmp);
                    }
                
            }
        }
        int ans = inf;
        for(int i = 0; i < sz; i++) 
            ans = min(dp[len][i], ans);
        if(ans == inf)
            return -1;
        return ans;
    }
}ac;

int main() 
{
    int n, kase = 1;
    char word[maxwl], txt[maxl];
    while(scanf("%d", &n) == 1 && n) {
        ac.init();
        for(int i = 0; i < n; i++) {
            scanf("%s", word);
            ac.insert(word);
        }
        ac.getfail();
        
        scanf("%s", txt);
        printf("Case %d: %d\n",kase++, ac.solve(txt));
    }
    return 0;
}

　　還有其他綜合型的題目，有興趣的同學自行嘗試（很刺激，一題坑一天的都是少的那種）。

　　至此，AC自動機解析及其在競賽中的典型應用就總結完了，算法很精妙，關鍵是體會算法的基本思想，加上一些具體的應用實踐，才能掌握牢固。AC自動機有很多變形，要想學好，用好，還需掌握其他知識，比如矩陣加速，高精度，狀壓DP（省略很多我還不知道的算法）。算法學習並非易事，要堅持思考，實踐，總結才行。（原創不易，轉載請注明出處哦）