[BZOJ2754][SCOI2012]喵星球上的点名（AC自动机+fail树）

=== ===

这里放传送门

=== ===

题解

据说这题暴力可做？可是ATP都忘了自己当时写的是不是暴力做法了2333因为时间太久了但是看起来好像不是暴力做法因为时间复杂度理论上讲好像挺科学的

首先要把所有点名串和姓和名都一起搞到AC自动机上，那么第一问是要问每个小串是多少个大串的子串。显然如果小串A是大串B的子串，那么从trie树的根节点到B的结束节点的路径上一定存在至少一个节点，沿着它的fail指针往上跳可以跳到A的结束节点。那么问题就转化成了在Fail树中，A的结束节点的子树中有多少种大串节点在里面出现。如果搞出dfs序这就变成了一个区间颜色种数问题，可以把所有需要询问的区间按照左端点从小到大排好序，然后对于颜色序列预处理每个点下一个和它相同颜色的点在哪里，先把每种颜色第一次出现的地方赋值为1其它地方赋值为0，这时候可以处理L=1的询问，就是一个区间和问题，可以用树状数组来做；然后要把左端点后移，就要把下一个和位置1相同颜色的点赋值为1，然后把1位置消除掉，这样就可以处理L=2的询问，以此类推。有一个问题就是在trie树中一个节点可能上面经过了多个串，也就是一个点可能有多个颜色，所以要用邻接链表记一下。

第二问是要求每个大串里面出现了多少种小串。仍然是利用Fail树，如果大串上的某一个节点它顺着fail指针往上跳的时候经过了小串的结尾节点那么这个小串就是这个大串的子串。那么就是要求所有大串的节点在fail树上到祖先的路径一共经过了多少种小串的结尾节点。那么先把小串的节点都在树上打上标记，然后把大串上的节点挑出来一个一个用倍增往上跳就可以了。为了避免重复计算的问题需要使用一个容斥一类的方法，就是把大串上的节点都按dfs序排好序存在一个数组a里面，那么每次在加入i=2..n的所有a[i]的路径和的时候都要减去a[i]和a[i-1]的LCA的路径和。这样就可以不重复地统计出来了。

代码

#include<map>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define Pow 18
#define inc(x)(x=(x%100000)+1)
using namespace std;
map<int,int>ch[200010];
int n,m,Atot,Etot,Ptot,v[100010],p[200010],a[200010],next[200010],w[200010],Pt[200010],Pa[200010],Pn[200010],end[100010];
int Fp[200010],Fa[200010],Fn[200010],Ftot,hd[200010],cnt,f[200010][20],g[200010][20],num[200010],t[200010],out[200010];
int fail[200010],deep[200010],is_end[200010];
struct query{
    int l,r,id;
}q[100010];
int comp(query a,query b){return a.l<b.l;}
int comp2(int a,int b){return w[a]<w[b];}
void add(int x,int y){
    ++Etot;a[Etot]=y;next[Etot]=p[x];p[x]=Etot;
}
void Padd(int x,int y){
    ++Ptot;Pa[Ptot]=y;Pn[Ptot]=Pt[x];Pt[x]=Ptot;
}
void Fadd(int x,int y){
    ++Ftot;Fa[Ftot]=y;Fn[Ftot]=Fp[x];Fp[x]=Ftot;
}
void insert(int *s,int len,int num){
    int now=0;
    for (int i=1;i<=len;i++){
        if (ch[now][s[i]]==0){
            add(now,s[i]);
            ch[now][s[i]]=++Atot;
        }
        if (num<=n) Padd(ch[now][s[i]],num);
        now=ch[now][s[i]];
    }
    if (num>n){
      end[num-n]=now+1;
      is_end[now+1]++;//注意这里不能用bool型
    }
}
void get_fail(){
    int q[100010],head,tail;
    head=tail=0;
    for (int i=p[0];i!=0;i=next[i]){
        inc(tail);q[tail]=ch[0][a[i]];Fadd(1,ch[0][a[i]]+1);
    }
    while (head!=tail){
        int u;
        inc(head);u=q[head];
        for (int i=p[u];i!=0;i=next[i]){
            int f,tmp=fail[u],v=ch[u][a[i]];
            while (ch[tmp][a[i]]==0&&tmp!=0) tmp=fail[tmp];//不能加路径压缩
            f=ch[tmp][a[i]];Fadd(f+1,v+1);
            fail[v]=f;inc(tail);q[tail]=v;
        }
    }
}
void dfs(){
    int u=1,cur[200010];
    bool flag=false;
    while (true){
        if (w[u]==0){
            deep[u]=deep[f[u][0]]+1;
            w[u]=++cnt;cur[u]=Fp[u];num[cnt]=u;
            for (int i=1;i<=Pow;i++){
                f[u][i]=f[f[u][i-1]][i-1];
                g[u][i]=g[f[u][i-1]][i-1]+g[u][i-1];
            }
        }
        flag=false;
        for (int i=cur[u];i!=0;i=Fn[i]){
            cur[u]=Fn[i];f[Fa[i]][0]=u;
            if (is_end[Fa[i]]!=0) g[Fa[i]][0]+=is_end[Fa[i]];
            u=Fa[i];flag=true;break;
        }
        if (flag==false){
            out[u]=cnt;
            if (u==0) break;
            else u=f[u][0];
        }
    }
}
int lowbit(int x){return x&(-x);}
void addnum(int i,int x){
    while (i<=Atot){t[i]+=x;i+=lowbit(i);}
}
int ask(int i){
    int ans=0;
    while (i!=0){ans+=t[i];i-=lowbit(i);}
    return ans;
}
void Firstquery(){
    int qcnt=0,ans[100010],L;
    for (int i=1;i<=m;i++){
        ++qcnt;q[qcnt].l=w[end[i]];
        q[qcnt].r=out[end[i]];
        q[qcnt].id=i;
    }
    sort(q+1,q+m+1,comp);
    memset(t,0,sizeof(t));L=1;
    for (int i=1;i<=n;i++)
      addnum(hd[i],1);
    for (int i=1;i<=m;i++){
        while (L<q[i].l){
            int t=ask(L);
            addnum(L,-t);
            for (int j=p[L];j!=0;j=next[j])
              if (a[j]!=-1) addnum(a[j],1);
            L++;
        }
        ans[q[i].id]=ask(q[i].r);
    }
    for (int i=1;i<=m;i++) printf("%d\n",ans[i]);
}
int rootsum(int x){
    int ans=0;
    for (int i=Pow;i>=0;i--)
      if (f[x][i]!=0){
          ans+=g[x][i];x=f[x][i];
      }
    return ans;
}
int LCA(int x,int y){
    if (deep[x]!=deep[y]){
        if (deep[x]<deep[y]) swap(x,y);
        for (int i=Pow;i>=0;i--)
          if (deep[f[x][i]]>=deep[y])
            x=f[x][i];
    }
    for (int i=Pow;i!=0;i--)
      if (f[x][i]!=f[y][i]){
        x=f[x][i];y=f[y][i];
      }
    while (x!=y){
        x=f[x][0];y=f[y][0];
    }
    return x;
}
void Secondquery(){
    int qu[100010],ans,qcnt;
    Etot=0;memset(p,0,sizeof(p));
    for (int i=1;i<=Atot;i++)
      for (int j=Pt[i];j!=0;j=Pn[j])
        add(Pa[j],i+1);
    for (int i=1;i<=n;i++){
        qcnt=ans=0;
        for (int j=p[i];j!=0;j=next[j])
          qu[++qcnt]=a[j];
        sort(qu+1,qu+qcnt+1,comp2);
        ans+=rootsum(qu[1]);
        for (int j=2;j<=qcnt;j++){
            ans+=rootsum(qu[j]);//容斥，加上它自己的再减去它和它前一个点的lca的
            ans-=rootsum(LCA(qu[j],qu[j-1]));
        }
        printf("%d",ans);
        if (i==n) printf("\n");
        else printf(" ");
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;i++){
        int len;
        scanf("%d",&len);
        for (int j=1;j<=len;j++) scanf("%d",&v[j]);
        insert(v,len,i);
        scanf("%d",&len);
        for (int j=1;j<=len;j++) scanf("%d",&v[j]);
        insert(v,len,i);
    }
    for (int i=1;i<=m;i++){
        int len;scanf("%d",&len);
        for (int j=1;j<=len;j++) scanf("%d",&v[j]);
        insert(v,len,i+n);
    }
    get_fail();
    dfs();Etot=0;Atot++;
    memset(p,0,sizeof(p));
    memset(hd,-1,sizeof(hd));
    for (int i=cnt;i>=1;i--){
        int v=num[i]-1;
        for (int j=Pt[v];j!=0;j=Pn[j]){
            if (i!=hd[Pa[j]]) add(i,hd[Pa[j]]);//当后继不是它自己的时候才加边
            hd[Pa[j]]=i;
        }//记录每个点按照dfs序的后继
    }
    Firstquery();
    Secondquery();
    return 0;
}

偏偏在最后出现的补充说明

AC自动机中Fail树的性质非常重要，可以用它来统计一些信息。