ac自动机最详细的讲解，让你一次学会ac自动机。

在没学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
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;
}