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

Solution

首先那个模数是没有用的....答案最大都不到那个模数。

然后注意到两个后缀的\(lcp\)长度就是他们后缀树上的\(lca\)的\(dis\)，所以建出后缀树之后对于每组询问建一棵虚树，在树上暴力统计答案就好了。

然后这题就真的码农了...

扫描二维码关注公众号，回复： 5408090 查看本文章

我反正码了一个多小时...

#include<bits/stdc++.h>
using namespace std;

#define ll long long 

void read(int &x) {
    x=0;int f=1;char ch=getchar();
    for(;!isdigit(ch);ch=getchar()) if(ch=='-') f=-f;
    for(;isdigit(ch);ch=getchar()) x=x*10+ch-'0';x*=f;
}
 
void print(ll x) {
    if(x<0) putchar('-'),x=-x;
    if(!x) return ;print(x/10),putchar(x%10+48);
}
void write(ll x) {if(!x) putchar('0');else print(x);putchar('\n');}

const int maxn = 1e6+10;

int n,m;
char s[maxn];
int id[maxn],dis[maxn],dfn[maxn],cnt[maxn],sz[maxn];

struct Suffix_Tree {
    int head[maxn],tot,dfn_cnt,f[maxn][20],dep[maxn];
    
    struct edge{int to,nxt;}e[maxn<<1];

    void add(int u,int v) {e[++tot]=(edge){v,head[u]},head[u]=tot;}
    void ins(int u,int v) {add(u,v),add(v,u);}

    void dfs(int x,int fa) {
        dfn[x]=++dfn_cnt;f[x][0]=fa;dep[x]=dep[fa]+1;sz[x]=1;
        for(int i=1;i<=18;i++) f[x][i]=f[f[x][i-1]][i-1];
        for(int i=head[x];i;i=e[i].nxt)
            if(e[i].to!=fa) dfs(e[i].to,x),sz[x]+=sz[e[i].to];
    }

    int lca(int x,int y) {
        if(dep[x]<dep[y]) swap(x,y);
        for(int i=18;~i;i--) if(dep[f[x][i]]>=dep[y]) x=f[x][i];
        if(x==y) return x;
        for(int i=18;~i;i--) if(f[x][i]!=f[y][i]) x=f[x][i],y=f[y][i];
        return f[x][0];
    }
}T;

struct Suffix_Automaton {
    int lstp,qs,cnt;
    int tr[maxn][26],par[maxn],ml[maxn];
    
    void clear() {lstp=qs=cnt=1;}

    void append(int x,int v) {
        int p=lstp,np=++cnt;ml[np]=ml[p]+1;id[v]=np;lstp=np;
        for(;p&&tr[p][x]==0;p=par[p]) tr[p][x]=np;
        if(!p) return par[np]=qs,void();
        int q=tr[p][x];
        if(ml[p]+1<ml[q]) {
            int nq=++cnt;ml[nq]=ml[p]+1;
            memcpy(tr[nq],tr[q],sizeof tr[nq]);
            par[nq]=par[q],par[q]=par[np]=nq;
            for(;p&&tr[p][x]==q;p=par[p]) tr[p][x]=nq;
        } else par[np]=q;
    }

    void prepare() {
        for(int i=2;i<=cnt;i++) T.ins(i,par[i]);
        for(int i=1;i<=cnt;i++) dis[i]=ml[i];
    }
}sam;

int cmp(int x,int y) {return dfn[x]<dfn[y];}

struct Virtual_Tree {
    ll ans;
    int head[maxn],tot,in[maxn],sta[maxn],use[maxn],used,top;
    
    struct edge{int to,nxt;}e[maxn<<1];

    void add(int u,int v) {e[++tot]=(edge){v,head[u]},head[u]=tot;}
    void ins(int u,int v) {add(u,v),add(v,u);}

    void dfs(int x,int fa) {
        for(int i=head[x];i;i=e[i].nxt)
            if(e[i].to!=fa) {
                dfs(e[i].to,x);
                ans+=1ll*dis[x]*cnt[x]*cnt[e[i].to];
                cnt[x]+=cnt[e[i].to];
            }
    }
    
    void solve() {
        int k;read(k);
        for(int i=1,x;i<=k;i++) read(x),in[i]=id[x],cnt[in[i]]=1;
        sort(in+1,in+k+1,cmp);k=unique(in+1,in+k+1)-in-1;
        sta[++top]=1;use[++used]=1;
        for(int i=1;i<=k;i++) {
            if(in[i]==1) continue;
            int pre=-1,t=T.lca(sta[top],in[i]);
            while(dfn[sta[top]]>dfn[t]&&dfn[sta[top]]<dfn[t]+sz[t]) {
                if(pre!=-1) ins(sta[top],pre);pre=sta[top],top--;
            }
            if(pre!=-1) ins(pre,t);
            if(sta[top]!=t) sta[++top]=t,use[++used]=t;
            sta[++top]=in[i];use[++used]=in[i];
        }
        int pre=-1;
        while(top) {if(pre!=-1) ins(sta[top],pre);pre=sta[top];top--;}
        ans=0;dfs(1,0);write(ans);
        for(int i=1,v;i<=used;i++) head[v=use[i]]=0,cnt[v]=0;
        used=top=tot=0;
    }
}VT;

int main() {
    read(n),read(m);
    scanf("%s",s+1);sam.clear();
    for(int i=1;i<=n;i++) sam.append(s[n-i+1]-'a',n-i+1);
    sam.prepare();T.dfs(1,0);
    for(int i=1;i<=m;i++) VT.solve();
    return 0;
}