AC自动机入门经典题目（两种表达方式）

Keywords Search

指针方式：

 /* Keywords Search */
 # include <iostream>
 # include <stdio.h>
 # include <string.h>
 # include <string>
 # include <cstdlib>
 # include <ctime>
 # include <cmath>
 # include <cctype>
 # include <vector>
 # include <deque>
 # include <queue>
 # include <stack>
 # include <climits>
 # include <bitset>
 # include <set>
 # include <map>
 using namespace std;

 # define N
 # define INF 0x3f3f3f3f
 # define lowbit(x)(x&(-x))

 struct node
 {
     int cnt;
     node *next[];
     node *fail;
     node(){
             cnt=;
             fail=NULL;
             memset(next, NULL, sizeof(next));
     }
 };
 node *root;
 char s[], str[N];
 int n;

 void init()
 {
     root = new node;
 }

 void _Insert(char *ss)
 {
     int len = strlen(ss);
     node *p=root;
     for(int i=; i<len; i++ )
     {
         int t=ss[i]-'a';
         if( p->next[t]==NULL )
             p->next[t]=new node;
         p=p->next[t];
     }
    p->cnt++;
 }

 void Build_the_fail()
 {
     root -> fail = NULL;
     //node *p=root;
     queue<node*>q;
     q.push(root);

     while( !q.empty() )
     {
         node *cur=q.front();
         q.pop();

         for(int i=; i<; i++ )
         {
             if( cur->next[i]!=NULL )
             {
                 if( cur==root )
                     cur->next[i]->fail = root;
                 else
                 {
                     node *p=cur->fail;
                     while( p!=NULL )
                     {
                         if( p->next[i]!=NULL )
                         {
                             cur->next[i]->fail = p->next[i];
                             break;
                         }

                         else
                         {
                             p = p -> fail;
                         }
                     }
                     if( p==NULL )
                         cur->next[i]->fail = root;
                 }
                 q.push(cur->next[i]);
             }
         }
     }
 }

 int query(char *str)
 {
     node *cur=root;
     int pos;
     int cont=;
     int len=strlen(str);
     for(int i=; i<len; i++ )
     {
         pos=str[i]-'a';
         while( cur->next[pos]==NULL && cur!=root )
         {
             cur = cur->fail;
         }
         cur = cur->next[pos];
         if( cur==NULL )
             cur = root;
         node *temp=cur;
         while( temp!=root )
         {
             if( temp->cnt!=- )
             {
                 cont += temp-> cnt;
                 temp -> cnt = -;
             }
             temp = temp -> fail;
         }
     }
     return cont;
 }

 int main()
 {
     int t;
     scanf("%d", &t);
     while( t-- )
     {
         init();
         scanf("%d", &n);
         for(int i=; i<n; i++ )
         {
             scanf("%s", s);
             _Insert(s);
         }
         Build_the_fail();
         scanf("%s", str);
         printf("%d\n", query(str));
     }
     return ;
 }

数组方式：

 /* */
 # include <iostream>
 # include <algorithm>
 # include <utility>
 # include <memory>
 # include <deque>
 # include <queue>
 # include <stack>
 # include <map>
 # include <set>
 # include <list>
 # include <vector>
 # include <cassert>
 # include <functional>
 # include <bitset>
 # include <cmath>
 # include <cstdlib>
 # include <climits>
 # include <cstring>
 # include <string>
 using namespace std;
 typedef long long ll;

 # define mem(a,b)(a,b,sizeof(a))
 # define lowbit(x)(x&(-x))
 # define lcm(a,b)(a*b/__gcd(a,b))
 const ll mod=1e9+;
 const int maxn=;
 const double pi=acos(-1.0);

 struct ac_auto
 {
     int Next[maxn][], Fail[maxn], End[maxn];//Next[now][buf[i]-'a'] 是now节点存着buf[i]字符的子节点的编号
     int L, root;//注意这是全局变量,L是编号,root是根节点

     int newNode(){
         for(int i=; i<; i++ )//26叉树
             Next[L][i] = -;
         End[L++] = ;
         return L-;//返回节点编号
     }

     void Initial(){
         L=;
         root = newNode();
     }

     void Insert( char buf[] )
     {
         int len=strlen(buf);
         int now = root;
         for(int i=; i<len; i++ )
         {
             if( Next[now][buf[i]-'a'] == - )
                 Next[now][buf[i]-'a'] = newNode();//若子节点没有buf[i],则插入buf[i]
             now = Next[now][buf[i]-'a'];//now是当前节点编号
         }
         End[now]++;//作为结束字符的编号+1,计算单词出现的次数
     }

     void Build_the_fail()
     {
         queue<int>ans;
         Fail[root] = root;//根节点的失败指针指向自己

         for(int i=; i<; i++ )
         {
             if( Next[root][i]==- )
                 Next[root][i] = root;
             else
             {
                 Fail[Next[root][i]] = root;//根节点的子节点的失败指针指向根节点
                 ans.push(Next[root][i]);
             }
         }

         while( !ans.empty() )
         {
             int now = ans.front();
             ans.pop();

             for(int i=; i<; i++)
             {
                 if( Next[now][i]==- )
                     Next[now][i] = Next[Fail[now]][i];//若buf[i]没有插入字典树，则将令其等于其父节点的失败指针指向的节点的子节点buf[i]字符所在的节点
                 else
                 {
                     Fail[Next[now][i]] = Next[Fail[now]][i];//若buf[i]已经插入,其失败指针就指向其父节点的失败指针指向的节点的子节点buf[i]所在的节点
                     ans.push(Next[now][i]);//
                 }
             }
         }
     }

     int Query( char buf[] )
     {
         int now = root;//从根节点开始找,now初始化为root
         int res = ;//结果
         int len = strlen(buf);

         for(int i=; i<len; i++ )
         {
             now = Next[now][buf[i]-'a'];//当前节点的编号
             int temp = now;
             while( temp!=root )
             {
                 res += End[temp];//只有找到单词最后一个字符所在位置End[temp]才会>0,否则为0,所以可以直接加
                 End[temp] = ;//加完后置为0
                 temp = Fail[temp];//拓展到失败指针指向的位置,继续找
             }
         }
         return res;
     }
 }AC;

 const int MAXN = ;
 int T, n;
 char buf[MAXN];

 int main()
 {
     ios::sync_with_stdio(false);
     cin>>T;
     while( T-- )
     {
         cin>>n;
         AC.Initial();
         for(int i=; i<n; i++ )
         {
             cin>>buf;
             AC.Insert(buf);
         }
         AC.Build_the_fail();
         cin>>buf;
         cout<<AC.Query(buf)<<endl;
     }
     return ;
 }