hdu4787 GRE Words Revenge，AC自动机，平方分割

hdu4787 GRE Words Revenge，AC自动机，乱搞，，
题意，给一些串（单词）学习，再给一些串（文章），要找出已学习的串中不同的串在该串中出现的次数总和。
强制在线。

如果一次将所有单词学完，再问这些文章中单词的出现次数，这就是AC自动机的裸题了。
但是这里要求边学习边询问。ac自动机的Build过程将会成为复杂度瓶颈，最差O(n^2)。

看时限比较宽松，这题需要用到根号n大法（平方分割法）。
建两个自动机，一个大的一个小的。
在小于根号n次插入时，将单词插到小的自动机上，每次插入需要重建自动机。
等于根号n次时，重建小自动机，把其中的节点都插到大自动机上。
总复杂度=O(n*sqrt(n)(小的)+O(sqrt(n)*n)(大的)=O(n*sqrt(n))。

有些自动机模板在Build过程中修改了son指针（比如我的），需要想一些办法才能解决。（re了我几个小时）

根号n要根据实际修改成适合的常数。

其实，这题暴力ac自动机也能过……只要在询问时才重新build即可。数据好水啊。。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;
#define NN 501000

int tottrie,q[NN*60],root[2];

struct trie{
       int fail;
       int son[2];
       int cnt;
       int tcnt;
       int len;
       void init(int _len=0){
           fail=0;
           cnt=0;
           tcnt=0;
           len=_len;
           son[0]=son[1]=0;
       }
}tt[NN];

void init(){
     tottrie=0;
     root[0]=++tottrie;
     root[1]=++tottrie;
     tt[0].init();
     tt[1].init();
     tt[2].init();
}

void insert(char *a,int num){
     int j=root[num];
     int i;
     while(*a){
        i=*a-'0';
        if (!tt[j].son[i]||tt[tt[j].son[i]].len<=tt[j].len) {
            tt[j].son[i]=++tottrie;tt[tottrie].init(tt[j].len+1);
        }
        j=tt[j].son[i];
        a++;
     }

     tt[j].cnt=1;
}

void dfs(int now){
    int i;
    tt[now].fail=0;
    tt[now].tcnt=tt[now].cnt;
    for(i=0;i<2;++i)if (tt[now].son[i]){
        if (tt[tt[now].son[i]].len<=tt[now].len) tt[now].son[i]=0;
        else dfs(tt[now].son[i]);
    }
}

void build_ac_automation(int num){
     int i,j,u,v;
     int rear=0,front=0;
     q[++rear]=root[num];
     dfs(root[num]);
     while(front<rear){
          u=q[++front];
          for(i=0;i<2;i++){
            j=tt[u].fail;
            while(j&&!tt[j].son[i]) j=tt[j].fail;
            if (tt[u].son[i]){
              v=tt[u].son[i];
              if (!j) tt[v].fail=root[num];
              else{
                  tt[v].fail=tt[j].son[i];
                  tt[v].tcnt+=tt[tt[j].son[i]].tcnt;
              }
              q[++rear]=v;
            }
            else {
              if (!j) tt[u].son[i]=root[num];
              else tt[u].son[i]=tt[j].son[i];
            }
          }

     }
}

int find(char *des,int num){
    int i,ret=0;
    int j,tmp;
    j=root[num];
    while(*des){
        i=*des-'0';
        if (!tt[j].son[i]||tt[tt[j].son[i]].len<=tt[j].len) return 0;
        j=tt[j].son[i];
        des++;
    }
    return tt[j].cnt;
}

int query(char *des,int num){
    int i,ret=0;
    int j,tmp;
    j=root[num];
    while(*des){
        i=*des-'0';
        if (j&&!tt[j].son[i]) j=tt[j].fail;
        j=tt[j].son[i];
        if (!j) j=root[num];
        ret+=tt[j].tcnt;
        des++;
    }
    return ret;
}

char s[NN*200],s2[NN*200];

vector<string> vs;

void reinsert(int tot){
    for(int i=0;i<tot;++i){
        strcpy(s2,vs[i].c_str());
        insert(s2,0);
    }
}

int main(){
    //freopen("gin.txt","r",stdin);
    int tcas,cas,n,tot,lastval;
    int i,j,tmp,l,builded;
    scanf("%d",&tcas);
    for(cas=1;cas<=tcas;++cas){
        scanf("%d",&n);
        init();
        tot=0;
        lastval=tmp=0;
        builded=0;
        vs.clear();
        printf("Case #%d:\n",cas);
        build_ac_automation(0);
        for(i=1;i<=n;++i){
            scanf("%s",s);
            l=strlen(s)-1;

            for(j=0;j<l;++j){
                s2[j]=s[1+(j+(lastval%l))%l];
            }
            s2[l]='\0';
            if (s[0]=='+') {
                if (find(s2,0)||find(s2,1)) continue;
                if (tot<50){
                    insert(s2,1);
                    builded=0;
                    ++tot;
                    string tst;
                    tst=s2;
                    vs.push_back(tst);
                }
                else {
                    insert(s2,0);
                    reinsert(tot);
                    build_ac_automation(0);

                    tt[root[1]].init();
                    tot=0;
                    vs.clear();
                }
            }
            else {
                if (builded==0) {
                    build_ac_automation(1);
                    builded=1;
                }
                tmp=query(s2,1)+query(s2,0);
                lastval=tmp;
                printf("%d\n",tmp);
            }
        }
    }
    return 0;
}