CF666E Forensic Examination SAM+倍增，线段树和并

题面：

　　给你一个串S以及一个字符串数组T[1..m]，q次询问，每次问S的子串S[p_l..p_r]在T[l..r]中的哪个串里的出现次数最多，并输出出现次数。如有多解输出最靠前的那一个。

分析：

　　第一次见这道题时，由于对算法十分陌生，就将其压进了任务计划，这一天又提到了这道题，这才算是重见天日。

　　数据结构题，越来越注重多种数据结构的搭配使用。搭配使用呢，我们就要知道各种数据结构的功能与适用范围，下面是这道题一个理想的思考过程（虽然我是抄的题解……）

　　首先，一个模式串的区间要在多个串上进行匹配，我们可以想到多串构造的广义后缀自动机。

　　由于我们要对一个模式串的区间，询问：在一个区间的匹配串中，最多出现在哪个匹配串，以及出现了多少次。（有点拗口）

　　我们需要使用一个支持区间查询的数据结构，并且，我们需要支持在SAM上，查询一个点的right集合中的所有点的信息。

　　我们采取的策略是，对于SAM的每一个点，我们建一棵值域为1~m的权值线段树，然后离线处理询问，将询问挂链（开vector存下来应该也可以），然后自底向上线段树合并，回答询问。

　　但是，我们对询问应该怎样调整一下呢，总不能对于每个区间都在广义SAM上跑一遍吧~

　　我们要总地把模式串S在SAM上跑一遍，只需要对每个询问记录右端点qr，当S匹配到这个点的时候，将所有右端点为qr的询问挂到链上，（为什么不直接挂链呢，因为我们不能随便挂链，需要挂到SAM上最早包含模式串这一段的那个点上（也就是匹配到当前点时，parent树上最远的一个len大于这一段长度的点上）），这里言语很难解释，只有自己体会这样做的妙处。但是这步操作怎么做呢，暴跳的话理论复杂度是过不去的（但实际上过得去），所以我们最好用一个倍增数组来做这个。（万一被hack掉可就不好了）

　　然后这道题跑线段树合并即可，由于是抄的题解代码，所以代码风格不太对（除了压行风格）请理智吸收。

代码：

 #include<bits/stdc++.h>
 using namespace std;
 const int N=;
 struct SAM{
     struct node{
         int son[],fa,l;
     }t[N];int lst,cnt;
     void init(){lst=cnt=;}
     void ins(int c){
         int p=lst,np=++cnt;lst=np;
         t[np].l=t[p].l+;
         for(;p&&!t[p].son[c];p=t[p].fa)
         t[p].son[c]=np;if(!p) t[np].fa=;
         else{
             int q=t[p].son[c];
             if(t[q].l==t[p].l+) t[np].fa=q;
             else{
                 int nq=++cnt;t[nq]=t[q];
                 t[nq].l=t[p].l+;
                 t[q].fa=t[np].fa=nq;
                 while(p&&t[p].son[c]==q)
                 t[p].son[c]=nq,p=t[p].fa;
             }
         }
     }
 }sam;int n,m,f[N][];
 struct data{int v,p;}ans[N];
 bool operator<(data a,data b){
     return (a.v<b.v)||(a.v==b.v&&a.p>b.p);
 } struct segtree{int ls,rs;data v;}t[N<<];
 struct que{int l,r,pl,pr;}q[N];
 int tot,rt[N];char S[N],T[N];
 void update(int &x,int l,int r,int p){
     if(!x) x=++tot;if(l==r)
     {t[x].v.v++;t[x].v.p=p;return;}
     int mid=l+r>>;
     if(p<=mid) update(t[x].ls,l,mid,p);
     else update(t[x].rs,mid+,r,p);
     t[x].v=max(t[t[x].ls].v,t[t[x].rs].v);
 } int merge(int x,int y){
     if(!y||!x) return x|y;
     if(!t[x].ls&&!t[x].rs)
     {t[x].v.v+=t[y].v.v;return x;}
     t[x].ls=merge(t[x].ls,t[y].ls);
     t[x].rs=merge(t[x].rs,t[y].rs);
     t[x].v=max(t[t[x].ls].v,t[t[x].rs].v);
     return x;
 } data query(int x,int l,int r,int L,int R){
     if(L<=l&&r<=R) return t[x].v;
     int mid=l+r>>;if(R<=mid)
     return query(t[x].ls,l,mid,L,R);
     if(L>mid) return query(t[x].rs,mid+,r,L,R);
     return max(query(t[x].ls,l,mid,L,R),
     query(t[x].rs,mid+,r,L,R));
 } struct link{
     struct line{int y,nxt;}e[N];
     int h[N],c;void add(int x,int y)
     {e[++c]=(line){y,h[x]};h[x]=c;}
 }par,qy,aw;void dfs(int x){
     for(int i=par.h[x];i;i=par.e[i].nxt)
     dfs(par.e[i].y),rt[x]=merge(rt[x],rt[par.e[i].y]);
     for(int i=aw.h[x];i;i=aw.e[i].nxt)
     ans[aw.e[i].y]=query(rt[x],,m,q[aw.e[i].y].l,
     q[aw.e[i].y].r);return ;
 } int main(){
     scanf("%s",S+);n=strlen(S+);
     scanf("%d",&m);sam.init();
     for(int i=;i<=m;i++){
         sam.lst=;scanf("%s",T+);
         for(int j=,l=strlen(T+);j<=l;j++)
         sam.ins(T[j]-),update(rt[sam.lst],,m,i);
     } int Q;scanf("%d",&Q);
     for(int i=,l,r,pl,pr;i<=Q;i++){
         scanf("%d%d%d%d",&l,&r,&pl,&pr);
         q[i]=(que){l,r,pl,pr};qy.add(q[i].pr,i);
     } for(int i=;i<=sam.cnt;i++)
     par.add(f[i][]=sam.t[i].fa,i);
     for(int i=;i<;i++)
     for(int j=;j<=sam.cnt;j++)
     f[j][i]=f[f[j][i-]][i-];
     for(int i=,nw=,len=;i<=n;i++){
         int c=S[i]-;
         while(nw&&!sam.t[nw].son[c])
         nw=sam.t[nw].fa,len=sam.t[nw].l;
         if(!nw){nw=,len=;continue;}
         nw=sam.t[nw].son[c];len+=;
         for(int j=qy.h[i];j;j=qy.e[j].nxt){
             int y=qy.e[j].y,x=nw,tmp;
             tmp=q[y].pr-q[y].pl+;
             if(len<tmp) continue;
             for(int k=;~k;k--)
             if(sam.t[f[x][k]].l>=tmp) x=f[x][k];
             aw.add(x,y);
         }
     } dfs();
     for(int i=;i<=Q;i++){
         if(!ans[i].v) ans[i].p=q[i].l;
         printf("%d %d\n",ans[i].p,ans[i].v);
     } return ;
 }

理论上过得去但跑的慢

 //这是CF666E理论上过不去（但实际上过得去）的代码
 #include<bits/stdc++.h>
 using namespace std;
 const int N=;
 struct SAM{
     struct node{
         int son[],fa,l;
     }t[N];int lst,cnt;
     void init(){lst=cnt=;}
     void ins(int c){
         int p=lst,np=++cnt;lst=np;
         t[np].l=t[p].l+;
         for(;p&&!t[p].son[c];p=t[p].fa)
         t[p].son[c]=np;if(!p) t[np].fa=;
         else{
             int q=t[p].son[c];
             if(t[q].l==t[p].l+) t[np].fa=q;
             else{
                 int nq=++cnt;t[nq]=t[q];
                 t[nq].l=t[p].l+;
                 t[q].fa=t[np].fa=nq;
                 while(p&&t[p].son[c]==q)
                 t[p].son[c]=nq,p=t[p].fa;
             }
         }
     }
 }sam;int n,m,f[N][];
 struct data{int v,p;}ans[N];
 bool operator<(data a,data b){
     return (a.v<b.v)||(a.v==b.v&&a.p>b.p);
 } struct segtree{int ls,rs;data v;}t[N<<];
 struct que{int l,r,pl,pr;}q[N];
 int tot,rt[N];char S[N],T[N];
 void update(int &x,int l,int r,int p){
     if(!x) x=++tot;if(l==r)
     {t[x].v.v++;t[x].v.p=p;return;}
     int mid=l+r>>;
     if(p<=mid) update(t[x].ls,l,mid,p);
     else update(t[x].rs,mid+,r,p);
     t[x].v=max(t[t[x].ls].v,t[t[x].rs].v);
 } int merge(int x,int y){
     if(!y||!x) return x|y;
     if(!t[x].ls&&!t[x].rs)
     {t[x].v.v+=t[y].v.v;return x;}
     t[x].ls=merge(t[x].ls,t[y].ls);
     t[x].rs=merge(t[x].rs,t[y].rs);
     t[x].v=max(t[t[x].ls].v,t[t[x].rs].v);
     return x;
 } data query(int x,int l,int r,int L,int R){
     if(L<=l&&r<=R) return t[x].v;
     int mid=l+r>>;if(R<=mid)
     return query(t[x].ls,l,mid,L,R);
     if(L>mid) return query(t[x].rs,mid+,r,L,R);
     return max(query(t[x].ls,l,mid,L,R),
     query(t[x].rs,mid+,r,L,R));
 } struct link{
     struct line{int y,nxt;}e[N];
     int h[N],c;void add(int x,int y)
     {e[++c]=(line){y,h[x]};h[x]=c;}
 }par,qy,aw;void dfs(int x){
     for(int i=par.h[x];i;i=par.e[i].nxt)
     dfs(par.e[i].y),rt[x]=merge(rt[x],rt[par.e[i].y]);
     for(int i=aw.h[x];i;i=aw.e[i].nxt)
     ans[aw.e[i].y]=query(rt[x],,m,q[aw.e[i].y].l,
     q[aw.e[i].y].r);return ;
 } int main(){
     scanf("%s",S+);n=strlen(S+);
     scanf("%d",&m);sam.init();
     for(int i=;i<=m;i++){
         sam.lst=;scanf("%s",T+);
         for(int j=,l=strlen(T+);j<=l;j++)
         sam.ins(T[j]-),update(rt[sam.lst],,m,i);
     } int Q;scanf("%d",&Q);
     for(int i=,l,r,pl,pr;i<=Q;i++){
         scanf("%d%d%d%d",&l,&r,&pl,&pr);
         q[i]=(que){l,r,pl,pr};qy.add(q[i].pr,i);
     } for(int i=;i<=sam.cnt;i++)
     par.add(f[i][]=sam.t[i].fa,i);
     for(int i=,nw=,len=;i<=n;i++){
         int c=S[i]-;
         while(nw&&!sam.t[nw].son[c])
         nw=sam.t[nw].fa,len=sam.t[nw].l;
         if(!nw){nw=,len=;continue;}
         nw=sam.t[nw].son[c];len+=;
         for(int j=qy.h[i];j;j=qy.e[j].nxt){
             int y=qy.e[j].y,x=nw,tmp;
             tmp=q[y].pr-q[y].pl+;
             if(len<tmp) continue;
             while(sam.t[f[x][]].l>=tmp) x=f[x][];
             aw.add(x,y);
         }
     } dfs();
     for(int i=;i<=Q;i++){
         if(!ans[i].v) ans[i].p=q[i].l;
         printf("%d %d\n",ans[i].p,ans[i].v);
     } return ;
 }

理论上过不去但跑得更快