Trie图

AC自动机是KMP的多串形式，当文本串失配时，AC自动机的fail指针告诉我们应该跳到哪里去继续匹配（跳到当前匹配串的最长后缀去），所以AC自动机的状态是有限的

但是AC自动机具有不确定性， 比如要求x结点的孩子c的fail指针（x->next[c]->fail)， 如果x的fail指针指向的结点没有c孩子(x-fail->next[c]==NULL)，

那么就要去看x的fail指针指向的结点的的fail指针指向的结点有没有孩子c(x->fail->fail->next[c] 是否为NULL），一直这样子迭代， 知道fail指针指向根结点为止

这样子的原因在于next指针的指向可能为空， Trie图就是补全了这些next指针的AC自动机，所以Trie图是确定性的有限状态自动机

那么如果补全这些next指针呢?

首先让第二层为空的next指针（第一层是根结点）都指向root，这是成里的， 如果匹配的时候如果第一个字符就不匹配， 那么肯定是回到root重新匹配

然后让下一层为空的next[i]指针指向上一层fail指针指向的next[i]指针（即也是指向自己的最长后缀）

Trie图的fail指针的求法与AC自动机一样， 这样子就能构件出Trie图了

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <algorithm>
 #include <iostream>
 #include <queue>
 #include <stack>
 #include <vector>
 #include <map>
 #include <set>
 #include <string>
 #include <math.h>
 using namespace std;
 #pragma warning(disable:4996)
 typedef unsigned __int64 LL;
 const int INF = <<;
 /*
 */
 const int N = ;
 struct Node
 {
     int fail, next[];
     bool isWord;
     void init()
     {
         fail = -;
         isWord = false;
         for (int i = ; i < ; ++i)
             next[i] = -;
     }
 }Trie[N];
 int size;
 void insert(int root, char *str)
 {
     int idx, cur = root;
     for (int i = ; str[i]; ++i)
     {
         idx = str[i] - 'a';
         if (Trie[cur].next[idx] == -)
         {
             Trie[size].init();
             Trie[cur].next[idx] = size++;
         }
         cur = Trie[cur].next[idx];
     }
     Trie[cur].isWord = true;
 }
 void makeFail(int root)
 {
     queue<int> q;
     for (int i = ; i < ; ++i)
     {
         if (Trie[root].next[i] == -)
             Trie[root].next[i] = root;
         else
         {
             Trie[Trie[root].next[i]].fail = root;
             q.push(Trie[root].next[i]);
         }
     }
     while (!q.empty())
     {
         int cur = q.front();
         q.pop();
         for (int i = ; i < ; ++i)
         {
             if (Trie[Trie[cur].fail].isWord)
                 Trie[cur].isWord = true;
             if (Trie[cur].next[i] == -)
                 Trie[cur].next[i] = Trie[Trie[cur].fail].next[i];
             else
             {
                 Trie[Trie[cur].next[i]].fail = Trie[Trie[cur].fail].next[i];
                 q.push(Trie[cur].next[i]);
             }
         }
     }
 }

 int main()
 {
     int n, L;
     char word[];
     while (scanf("%d", &n,) != EOF)
     {
         Trie[].init();
         Trie[].fail = ;
         size = ;
         for (int i = ; i < n; ++i)
         {
             scanf("%s", word);
             insert(, word);
         }
         makeFail();

     }
     return ;
 }