HDU4787_GRE Words Revenge

这个题目做得泪牛满面。

题目为给你若干串，有的表示添加一个串，有的表示询问一个串有多少个字串为前面出现过的串。

题目一看就知道肯定是AC自动机（不过后缀自动机也是可以的）

但是细想就会发现AC自动机好像不支持在线修改。如果你每次读入一个串就重构一次AC自动机的话，那么时间复杂度达到了N^2，肯定会T的。

于是就产生了一种奇葩的解法。

搞两个自动机，一个自动机为大的自动机，一个自动机为小的自动机（用于缓冲）。每次我都只把字符串加入到小的自动机里面并且重构小自动机，当小自动机的容量超过了sqrt(L)的时候，我们把小自动机合并到大自动机上，这样算下来时间复杂度为O(L*sqrt(L))，每次询问的答案就是大小自动机上查询答案的和，好像是可以AC的。

但是问题来了，怎么合并两个自动机呢？

其实很简单，自动机相对于字典树来说有什么区别呢？一个是tire树，一个是tire图，自动机多了fail指针还多了一些新建立的next指针。所以我们只要把这些多余的指针去掉，然后对小字典树做一次搜索就可以吧两个字典树合并了。然后重构了一次大自动机，小自动机清空，就可以了。

总的时间复杂度有点勉强，不过算下来10^5好像理论上来说也是可以过的。

赞一个，题目出的太好了。

不过听说还有用后缀自动机做，并且用动态树来维护的。不明觉厉啊。求神犇指点。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#define maxn 100050
using namespace std;

int next[][maxn][],has[][maxn][],tag[][maxn],sum[][maxn],fail[][maxn],N[];
char s0[*maxn],s[*maxn];
int qx[maxn],qy[maxn],tq;
int ans,n,t;

int add(int x)
{
    N[x]++;
    next[x][N[x]][]=next[x][N[x]][]=;
    has[x][N[x]][]=has[x][N[x]][]=;
    tag[x][N[x]]=;
    sum[x][N[x]]=;
    fail[x][N[x]]=;
    return N[x];
}

void init(int x)
{
    N[x]=-;
    N[x]=add(x);
}

void initall()
{
    ans=;
    init(),init();
}

void getstring()
{
    scanf("%s",s0);
    int L=strlen(s0)-,cur=;
    for (int i=ans%L+; s0[i]; i++) s[cur]=s0[i],cur++;
    for (int i=; i<=ans%L; i++) s[cur]=s0[i],cur++;
    s[L]=;
}

void destory(int x)
{
    for (int i=; i<=N[x]; i++)
    {
        fail[x][i]=;
        for (int j=; j<; j++)
            if (has[x][i][j]==) next[x][i][j]=;
    }
}

void insert()
{
    int cur=,tep;
    for (int i=; s[i]; i++)
    {
        tep=s[i]-'';
        if (next[][cur][tep]==)
        {
            next[][cur][tep]=add();
            has[][cur][tep]=;
        }
        cur=next[][cur][tep];
    }
    tag[][cur]=;
}

void union01()
{
    int cur=;
    qx[]=qy[]=;
    while (cur>)
    {
        int xx=qx[cur],yy=qy[cur];
        if (tag[][yy]) tag[][xx]=;
        cur--;
        for (int i=; i<; i++)
        {
            if (next[][yy][i])
            {
                if (next[][xx][i]==)
                {
                    next[][xx][i]=add();
                    has[][xx][i]=;
                }
                cur++;
                qx[cur]=next[][xx][i];
                qy[cur]=next[][yy][i];
            }
        }
    }
}

void AC_build(int x)
{
    for (int i=; i<=N[x]; i++) sum[x][i]=tag[x][i];
    queue<int> Q;
    int cur,child;
    Q.push();
    while (!Q.empty())
    {
        cur=Q.front(),Q.pop();
        for (int i=; i<; i++)
        {
            child=next[x][cur][i];
            if (child)
            {
                Q.push(child);
                if (cur==) fail[x][child]=;
                else
                {
                    fail[x][child]=next[x][fail[x][cur]][i];
                    sum[x][child]+=sum[x][fail[x][child]];
                }
            }
            else next[x][cur][i]=next[x][fail[x][cur]][i];
        }
    }
}

int query(int x)
{
    int cur=,tep,tot=;
    for (int i=; s[i]; i++)
    {
        tep=s[i]-'';
        cur=next[x][cur][tep];
        tot+=sum[x][cur];
    }
    return tot;
}

bool find(int x)
{
    int cur=,tep;
    for (int i=; s[i]; i++)
    {
        tep=s[i]-'';
        if (has[x][cur][tep]) cur=next[x][cur][tep];
            else return false;
    }
    if (tag[x][cur]==) return false;
    return true;
}

int main()
{
    int cas=;
    scanf("%d",&t);
    while (t--)
    {
        printf("Case #%d:\n",++cas);
        initall();
        scanf("%d",&n);
        while (n--)
        {
            getstring();
            if (s0[]=='+')
            {
                if (find() || find()) continue;
                destory();
                insert();//insert s to trie 1
                if (N[]>=)
                {
                    destory();
                    union01();
                    AC_build();
                    init();
                }
                else AC_build();
            }
            else if (s0[]=='?')
            {
                ans=query()+query();
                printf("%d\n",ans);
            }
        }
    }
    return ;
}