在沒學ac自動機之前，覺得ac自動機是個很神奇，很高深，很難的演算法，學完之後發現，ac自動機確實很神奇，很高深，但是卻並不難。 
我說ac自動機很神奇，在於這個演算法中失配指標的妙處（好比kmp演算法中的next陣列），說它高深，是因為這個不是一般的演算法，而是建立在兩個普通演算法的基礎之上，而這兩個演算法就是kmp與字典樹。所以，如果在看這篇部落格之前，你還不會字典樹或者kmp演算法，那麼請先學習字典樹或者kmp演算法之後再來看這篇部落格。好了，閒話扯完了，下面進入正題。

在學習一個新東西之前，一定要知道這個東西是什麼，有什麼用，我們學它的目的是什麼，如果對這些東西沒有一個清楚的把握，我不認為你能學好這個新知識。 
那麼首先我們來說一下ac自動機是什麼。下面是我從百度上找的。Aho-Corasick automaton，該演算法在1975年產生於貝爾實驗室，是著名的多模匹配演算法。 
從上面我們可以知道，ac自動機其實就是一種多模匹配演算法，那麼你可能會問什麼叫做多模匹配演算法。下面是我對多模匹配的理解，與多模與之對於的是單模，單模就是給你一個單詞，然後給你一個字串，問你這個單詞是否在這個字串中出現過（匹配），這個問題可以用kmp演算法在比較高效的效率上完成這個任務。那麼現在我們換個問題，給你很多個單詞，然後給你一段字串，問你有多少個單詞在這個字串中出現過，當然我們暴力做，用每一個單詞對字串做kmp,這樣雖然理論上可行，但是時間複雜度非常之高，當單詞的個數比較多並且字串很長的情況下不能有效的解決這個問題，所以這時候就要用到我們的ac自動機演算法了。 
對於上面的文字，我已經回答了什麼是多模匹配和我們為什麼要學習ac自動機那就是ac自動機的作用是什麼等一系列問題。下面是ac自動機的具體實現步驟以及模板程式碼。 
1.把所有的單詞建立一個字典樹。 
在建立字典樹之前，我們先定義每個字典樹上節點的結構體變數

struct node{
    node *next[26];
    node *fail;
    int sum;
};

其中fail 是失配指標 
sum是這個節點是不是一個單詞的結尾，以及相應的個數。 
下面是字典樹的建立過程

void Insert(char *s)
{
    node *p = root;
    for(int i = 0; s[i]; i++)
    {
        int x = s[i] - 'a';
        if(p->next[x] == NULL)
        {
            newnode=(struct node *)malloc(sizeof(struct node));
            for(int j=0;j<26;j++) newnode->next[j] = 0;
            newnode->sum = 0;newnode->fail = 0;
            p->next[x]=newnode;
        }
        p = p->next[x];
    }
    p->sum++;
}
 

注意在建立字典樹的過程中，先讓每個節點的fail指標先為空。 
下面就是ac自動機最關鍵的一步，求解每個節點的失配指標，我在這裡先說一下失配指標具體表示什麼，每個節點的失配指標指向的是以當前節點表示的字元為最後一個字元的最長當前字串的字尾字串的最後一個節點。可能在這裡你可能不怎麼懂，沒關係，光看上面的文字，肯定難以看懂，下面我用一個圖來簡單的表示一下，有助於你理解。

假如我們有四個單詞，abcd, bce, abd, cd,那麼我們建立字典樹如下： 
 
首先我們讓與根節點直接相連的節點的fail直接指向root,為了讓你更好的理解fail指標，我們以節點x,y,z為例，我們讓從圖中我們可以看出x節點的fail指向了y節點，y節點的fail指向了z節點，為什麼會這樣指，因為x節點表示字串abc,而字典樹中含有最長，且以c結尾，且是abc的字尾的字串bc(以y節點結尾的），同理，以y節點表示的字串是bc,而以c結尾，且是bc的字尾的最長字串是c（以z節點結尾的）。這就是fail指標指向的目標，那麼我們得到了這個fail指標在匹配中有什麼用呢，我們還是用上面的那個圖來舉例說明一下，假設文字串是abce,通過字典樹我們可以看出，通過abc,所以我們可以匹配到x節點，但是到後面，我們發現d與e不匹配，這時我們就需要用到當前節點的fail了，因為x的fail指向的是y節點，所以我們直接跳到y節點，這是發現y節點後面有e，匹配上了，所以單詞bce就在文字串abce中被檢測出來了。當然這只是最簡單的一種情況。 
下面是構造fail指標的具體程式碼。 
基於佇列（bfs）實現的。

void build_fail_pointer()
{
    head = 0;
    tail = 1;
    q[head] = root;
    node *p;
    node *temp;
    while(head < tail)
    {
        temp = q[head++];
        for(int i = 0; i <= 25; i++)
        {
            if(temp->next[i])
            {
                if(temp == root)
                {
                    temp->next[i]->fail = root;
                }
                else
                {
                    p = temp->fail;
                    while(p)
                    {
                        if(p->next[i])
                        {
                            temp->next[i]->fail = p->next[i];
                            break;
                        }
                        p = p->fail;
                    }
                    if(p == NULL) temp->next[i]->fail = root;
                }
                q[tail++] = temp->next[i];
            }
        }
    }
}

最後是利用前面求得的fail指標進行匹配。 
程式碼如下：

void ac_automation(char *ch)
{
    node *p = root;
    int len = strlen(ch);
    for(int i = 0; i < len; i++)
    {
        int x = ch[i] - 'a';
        while(!p->next[x] && p != root) p = p->fail;
        p = p->next[x];
        if(!p) p = root;
        node *temp = p;
        while(temp != root)
        {
           if(temp->sum >= 0)
           {
               cnt += temp->sum;
               temp->sum = -1;
           }
           else break;
           temp = temp->fail;
        }
    }
}

如果你還沒有看懂ac自動機，沒關係，細細品味，你一定能成功的。

如果你看懂了上面的講解，那麼我們可以做一道模板題來試試，以hdu2222為例，ac程式碼如下：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e7 + 5;
const int MAX = 10000000;
int cnt;
struct node{
    node *next[26];
    node *fail;
    int sum;
};
node *root;
char key[70];
node *q[MAX];
int head,tail;
node *newnode;
char pattern[maxn];
int N;
void Insert(char *s)
{
    node *p = root;
    for(int i = 0; s[i]; i++)
    {
        int x = s[i] - 'a';
        if(p->next[x] == NULL)
        {
            newnode=(struct node *)malloc(sizeof(struct node));
            for(int j=0;j<26;j++) newnode->next[j] = 0;
            newnode->sum = 0;newnode->fail = 0;
            p->next[x]=newnode;
        }
        p = p->next[x];
    }
    p->sum++;
}
void build_fail_pointer()
{
    head = 0;
    tail = 1;
    q[head] = root;
    node *p;
    node *temp;
    while(head < tail)
    {
        temp = q[head++];
        for(int i = 0; i <= 25; i++)
        {
            if(temp->next[i])
            {
                if(temp == root)
                {
                    temp->next[i]->fail = root;
                }
                else
                {
                    p = temp->fail;
                    while(p)
                    {
                        if(p->next[i])
                        {
                            temp->next[i]->fail = p->next[i];
                            break;
                        }
                        p = p->fail;
                    }
                    if(p == NULL) temp->next[i]->fail = root;
                }
                q[tail++] = temp->next[i];
            }
        }
    }
}
void ac_automation(char *ch)
{
    node *p = root;
    int len = strlen(ch);
    for(int i = 0; i < len; i++)
    {
        int x = ch[i] - 'a';
        while(!p->next[x] && p != root) p = p->fail;
        p = p->next[x];
        if(!p) p = root;
        node *temp = p;
        while(temp != root)
        {
           if(temp->sum >= 0)
           {
               cnt += temp->sum;
               temp->sum = -1;
           }
           else break;
           temp = temp->fail;
        }
    }
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        root=(struct node *)malloc(sizeof(struct node));
        for(int j=0;j<26;j++) root->next[j] = 0;
        root->fail = 0;
        root->sum = 0;
        scanf("%d",&N);
        getchar();
        for(int i = 1; i <= N; i++)
        {
            gets(key);
            Insert(key);
        }
        gets(pattern);
        cnt = 0;
        build_fail_pointer();
        ac_automation(pattern);
        printf("%d\n",cnt);
    }
    return 0;
}