BZOJ3879: SvT

3879: SvT

Time Limit: 30 Sec  Memory Limit: 512 MB
Submit: 149  Solved: 57
[Submit][Status][Discuss]

Description

(我并不想告诉你题目名字是什么鬼)

有一个长度为n的仅包含小写字母的字符串S,下标范围为[1,n].

现在有若干组询问,对于每一个询问,我们给出若干个后缀(以其在S中出现的起始位置来表示),求这些后缀两两之间的LCP(LongestCommonPrefix)的长度之和.一对后缀之间的LCP长度仅统计一遍.

 

 

Input

第一行两个正整数n,m,分别表示S的长度以及询问的次数.

接下来一行有一个字符串S.

接下来有m组询问,对于每一组询问,均按照以下格式在一行内给出:

首先是一个整数t,表示共有多少个后缀.接下来t个整数分别表示t个后缀在字符串S中的出现位置.

 

 

Output

对于每一组询问,输出一行一个整数,表示该组询问的答案.由于答案可能很大,仅需要输出这个答案对于23333333333333333(一个巨大的质数)取模的余数.

 

 

Sample Input

7 3

popoqqq

1 4

2 3 5

4 1 2 5 6

Sample Output

0

0

2

Hint

样例解释:

对于询问一,只有一个后缀”oqqq”,因此答案为0.

对于询问二,有两个后缀”poqqq”以及”qqq”,两个后缀之间的LCP为0,因此答案为0.

对于询问三,有四个后缀”popoqqq”,”opoqqq”,”qqq”,”qq”,其中只有”qqq”,”qq”两个后缀之间的LCP不为0,且长度为2,因此答案为2.

对于100%的测试数据,有S<=5*10^5,且Σt<=3*10^6.

特别注意:由于另一世界线的某些参数发生了变化,对于一组询问,即使一个后缀出现了多次,也仅算一次.

 

 

 

终于会写虚树了，抱着XYZ的论文看了一上午。

也不是很难写。。。虚树是这么构造的：

将所有关键点按欧拉序排序，求出相邻LCA。

将所有关键点和LCA放在一起，再排序去重。

如何得到虚树上的边呢？只要用一个栈维护跟到当前节点的链。

每次判断栈顶元素是不是x的祖先，如果不是则踢掉重复以上操作，是则添边，最后把x加入栈。

每次得到询问点的虚树就是《差异》那道题目了。

#include<cstdio>
#include<cctype>
#include<queue>
#include<cmath>
#include<cstring>
#include<algorithm>
#define rep(i,s,t) for(int i=s;i<=t;i++)
#define dwn(i,s,t) for(int i=s;i>=t;i--)
#define ren for(int i=first[x];i;i=next[i])
using namespace std;
inline int read() {
    int x=0,f=1;char c=getchar();
    for(;!isdigit(c);c=getchar()) if(c=='-') f=-1;
    for(;isdigit(c);c=getchar()) x=x*10+c-'0';
    return x*f;
}
typedef long long ll;
const int maxn=1000010;
int first[maxn],next[maxn],To[maxn],ToT,e;
void AddEdge(int u,int v) {
    To[++e]=v;next[e]=first[u];first[u]=e;
}
int anc[maxn][20],L[maxn],R[maxn],dep[maxn];
void dfs(int x) {
    L[x]=++ToT;dep[x]=dep[anc[x][0]]+1;
    rep(i,1,19) anc[x][i]=anc[anc[x][i-1]][i-1];
    ren anc[To[i]][0]=x,dfs(To[i]);
    R[x]=ToT;
}
int lca(int x,int y) {
    if(dep[x]<dep[y]) swap(x,y);
    dwn(i,19,0) if(1<<i<=dep[x]-dep[y]) x=anc[x][i];
    dwn(i,19,0) if(anc[x][i]!=anc[y][i]) x=anc[x][i],y=anc[y][i];
    return x==y?x:anc[x][0];
}
int n,m,to[maxn][26],pos[maxn],fa[maxn],l[maxn],cnt=1,last=1;
void extend(int c,int x) {
    int p=last,q,np,nq;l[last=np=++cnt]=l[p]+1;pos[x]=np;
    for(;!to[p][c];p=fa[p]) to[p][c]=np;
    if(!p) fa[np]=1;
    else {
        q=to[p][c];
        if(l[p]+1==l[q]) fa[np]=q;
        else {
            l[nq=++cnt]=l[p]+1;
            memcpy(to[nq],to[q],sizeof(to[q]));
            fa[nq]=fa[q];fa[q]=fa[np]=nq;
            for(;to[p][c]==q;p=fa[p]) to[p][c]=nq;
        }
    }
}
char s[maxn];
int A[maxn*3],S[maxn];
int cmp(int x,int y) {return L[x]<L[y];}
struct Solver {
    int first[maxn],next[maxn],to[maxn],is[maxn],e;
    void AddEdge(int u,int v) {
        to[++e]=v;next[e]=first[u];first[u]=e;
    }
    ll f[maxn],ans;
    ll solve(int x) {
        ren {
            solve(to[i]);
            ans+=f[x]*f[to[i]]*l[x];
            f[x]+=f[to[i]];
        }
    }
}T;
int main() {
    int n=read(),m=read();scanf("%s",s+1);
    dwn(i,n,1) extend(s[i]-'a',i);
    rep(i,2,cnt) AddEdge(fa[i],i);
    dfs(1);
    while(m--) {
        int k=read(),cnt=2*k-1,top=0,tmp=k;
        rep(i,1,k) T.f[A[i]=pos[read()]]=1;
        sort(A+1,A+k+1,cmp);
        rep(i,2,k) A[i+k-1]=lca(A[i-1],A[i]);
        sort(A+1,A+cnt+1,cmp);k=0;
        rep(i,1,cnt) if(A[i]!=A[i-1]) A[++k]=A[i];
        T.e=T.ans=0;rep(i,1,k) T.first[A[i]]=0;
        rep(i,1,k) {
            while(top&&(L[A[i]]<L[S[top]]||L[A[i]]>R[S[top]])) top--;
            if(top) T.AddEdge(S[top],A[i]);S[++top]=A[i];
        }
        T.solve(A[1]);printf("%lld\n",T.ans);
        rep(i,1,k) T.f[A[i]]=0;
    }
    return 0;
}