（AC自动机）UVALive - 4670 Dominating Patterns

题目地址

每组数据，对模式串建立Trie树，为避免模式串重复的情况，用mao建立模式串与编号的对应关系。

对匹配串AC自动机处理，其中print改为更新出现次数。

最后找一下次数最大的输出即可。

#include <iostream>
#include <string>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <queue>
#include <set>
#include <map>
#include <list>
#include <vector>
#include <stack>
#define mp make_pair
#define MIN(a,b) (a>b?b:a)
#define rank rankk
//#define MAX(a,b) (a>b?a:b)
typedef long long ll;
typedef unsigned long long ull;
const int MAX=1e6+5;
const int INF=1e9+5;
const int B=1024;//桶的大小
const double M=4e18;
using namespace std;
const int MOD=1e9+7;
typedef pair<int,int> pii;
const double eps=0.000000001;

map<string,int> re;
const int SIGMA_SIZE=50;
const int MAXNODE=11000;
const int MAXS=160;
/*
    由于失配过程比较复杂，要反复沿着失配边走，
    在实践中常常会把下述自动机改造一下，把所有不存在的边“补上”
    即把计算失配函数中的语句if(!u)continue;改成
    if(!u){ch[r][c]=ch[f[r]][c];continue;}
    这样，就完全不需要失配函数，而是对所有转移一视同仁
    即find函数中的while(j&&!ch[j][c])j=f[j] 可以直接删除

*/
struct AhoCorasickAutomata
{
    int ch[MAXNODE][SIGMA_SIZE];
    int f[MAXNODE];//fail函数
    int val[MAXNODE];//每个字符串的结尾结点都有非0的val
    int last[MAXNODE];//输出链表的下一个单词结点
    int num;//trie树编号（亦为包含根结点的当前size）
    int cnt[MAXNODE];
    //初始化
    void init()
    {
        num=1;
        memset(ch[0],0,sizeof(ch[0]));
        re.clear();
        memset(cnt,0,sizeof(cnt));
    }
    //返回字符对应编号
    int idx(char c)
    {
        return c-'a';
    }
    //插入权值为v的字符串
    void insert(char *s,int v)
    {
        int u=0,n=strlen(s);
        for(int i=0;i<n;i++)
        {
            int c=idx(s[i]);
            if(!ch[u][c])
            {
                memset(ch[num],0,sizeof(ch[num]));
                val[num]=0;
                ch[u][c]=num++;
            }
            u=ch[u][c];
        }
        val[u]=v;
        re[s]=v;
    }
    //递归打印以结点j结尾的所有字符串
    void print(int j)
    {
        if(j)
        {
            ++cnt[val[j]];
            print(last[j]);
//            printf("%d %d\n",j,val[j]);
//            print(last[j]);
        }
    }
    //计算fail函数
    void getFail()
    {
        queue <int> que;
        f[0]=0;
        for(int c=0;c<SIGMA_SIZE;c++)
        {
            int u=ch[0][c];
            if(u)
            {
                f[u]=0;que.push(u);last[u]=0;
            }
        }
        while(!que.empty())
        {
            int r=que.front();que.pop();
            for(int c=0;c<SIGMA_SIZE;c++)
            {
                int u=ch[r][c];
                if(!u)
                    continue;
                que.push(u);
                int v=f[r];
                while(v&&!ch[v][c])//类似kmp的过程
                    v=f[v];
                f[u]=ch[v][c];
                last[u]=val[f[u]]?f[u]:last[f[u]];
            }
        }
    }
    //在T中中模板
    int find(char *T)
    {
        int n=strlen(T);
        int u=0;//当前结点编号,初始为根结点
        for(int i=0;i<n;i++)//文本串当前指针
        {
            int c=idx(T[i]);
            while(u&&!ch[u][c])//顺着失配指针走，直到可以匹配或回到根节点
                u=f[u];
            u=ch[u][c];
            if(val[u])//当前位置恰好是某个模式串第一次出现
                print(u);
            else if(last[u])//当前位置作为后缀，与某前缀与模式串相同
                print(last[u]);
        }
    }

};
int n;
char tem[151][80];
char temp[MAX];
AhoCorasickAutomata ac;
int main()
{
    while(scanf("%d",&n)&&n)
    {
        ac.init();
        for(int i=1;i<=n;i++)
        {
            scanf("%s",tem[i]);
            ac.insert(tem[i],i);
        }
        ac.getFail();
        scanf("%s",temp);
        ac.find(temp);
        int an=-1;
        for(int i=1;i<=n;i++)
        {
            if(ac.cnt[i]>an)
            {
                an=ac.cnt[i];
            }
        }
        printf("%d\n",an);
        for(int i=1;i<=n;i++)
        {
            if(ac.cnt[re[string(tem[i])]]==an)
               {
                   printf("%s\n",tem[i]);
               }
        }
    }
    return 0;
}