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 1001000
# define INF 0x3f3f3f3f
# define lowbit(x)(x&(-x))

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

void init()
{
    root = new node;
}

void _Insert(char *ss)
{
    int len = strlen(ss);
    node *p=root;
    for(int i=0; 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=0; i<26; 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=0;
    int len=strlen(str);
    for(int i=0; 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!=-1 )
            {
                cont += temp-> cnt;
                temp -> cnt = -1;
            }
            temp = temp -> fail;
        }
    }
    return cont;
}

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

 

 数组方式：

/* */
# 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+7;
const int maxn=500010;
const double pi=acos(-1.0);

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


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

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

    void Insert( char buf[] )
    {
        int len=strlen(buf);
        int now = root;
        for(int i=0; i<len; i++ )
        {
            if( Next[now][buf[i]-'a'] == -1 )
                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=0; i<26; i++ )
        {
            if( Next[root][i]==-1 )
                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=0; i<26; i++)
            {
                if( Next[now][i]==-1 )
                    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 = 0;//结果
        int len = strlen(buf);

        for(int i=0; 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;//加完后置为0
                temp = Fail[temp];//拓展到失败指针指向的位置,继续找
            }
        }
        return res;
    }
}AC;

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

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