[NOI2018]你的名字(SAM+线段树合并)

考虑l=1,r=n的68分，对S和T建SAM，对T的SAM上的每个节点，计算它能给答案带来多少贡献。

T上节点x代表的本质不同的子串数为mx[x]-mx[fa[x]]，然后需要去掉所代表子串与S的最长公共子串的长度。

从1到length(T)扫一遍，SAM基本操作求出每个前缀与S的最长公共子串。

答案为$\sum_{i=1}^{cnt}max(0,mx[x]-max(mx[fa[x]],len[tag[x]]))$，其中tag[x]是x所代表的子串在T中的第一个出现位置，len[i]为T的前缀i与S的最长公共子串。

再考虑l,r任意的情况，唯一区别在于求某前缀与S的最长公共子串时，需要满足[l,r]的限制。

即若想判断当前公共子串长是否可以为len，那么当前走到的点的parent树的子树内必须存在一个串的Right在[l+len,r]中。

“某子树内是否存在[l+len,r]中的值”显然可以用主席树做，或可持久化线段树合并。

下面大概证一下线段树合并的时空复杂度：

1.由于每次合并时，若发现x与y的当前子树有一个为空则退出。这种情况每个节点最多会出现一次（合并之后这个位置就不再为空了），故这部分复杂度为$O(n\log n)$。

2.除去情况一，则x与y合并的复杂度为两个树的重合节点个数。最坏情况发生在依次将一个个只有一个节点的树合并进来，这部分显然仍然是$O(n\log n)$的。

3.不可持久化的线段树合并并不产生新节点，故空间复杂度为初始插入n个点的复杂度：$O(n\log n)$

4.可持久化的线段树，根据算法流程容易发现时空复杂度同阶，于是复杂度也为$O(n\log n)$

 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #define lson ls[x],L,mid
 #define rson rs[x],mid+1,R
 #define rep(i,l,r) for (int i=(l); i<=(r); i++)
 typedef long long ll;
 using namespace std;

 const int N=,M=;
 char s[N],t[N];
 int n,m,nd,Q,l,r,len[N],rt[N],id[N],ls[M],rs[M];

 struct SAM{
     int nd,lst,mx[N],fa[N],pos[N],son[N][];

     void init(){
         nd=; lst=;
         rep(i,,m*) fa[i]=mx[i]=;
         rep(i,,m*) rep(j,,) son[i][j]=;
     }

     void ext(int c,int x){
         int p=lst,np=lst=++nd; pos[np]=x; mx[np]=mx[p]+;
         while (p && !son[p][c]) son[p][c]=np,p=fa[p];
         if (!p) fa[np]=;
         else{
             int q=son[p][c];
             if (mx[q]==mx[p]+) fa[np]=q;
             else{
                 int nq=++nd; pos[nq]=pos[q]; mx[nq]=mx[p]+;
                 memcpy(son[nq],son[q],sizeof(son[q]));
                 fa[nq]=fa[q]; fa[q]=fa[np]=nq;
                 while (p && son[p][c]==q) son[p][c]=nq,p=fa[p];
             }
         }
     }

 }S,T;

 bool cmp(int a,int b){ return S.mx[a]<S.mx[b]; }

 void ins(int &x,int L,int R,int k){
     if (!x) x=++nd;
     if (L==R) return;
     int mid=(L+R)>>;
     if (k<=mid) ins(lson,k); else ins(rson,k);
 }

 bool que(int x,int L,int R,int l,int r){
     if (!x) return ;
     if (L==l && r==R) return ;
     int mid=(L+R)>>;
     if (r<=mid) return que(lson,l,r);
     else if (l>mid) return que(rson,l,r);
         else return que(lson,l,mid)|que(rson,mid+,r);
 }

 int merge(int x,int y){
     if (!x || !y) return x|y;
     int now=++nd;
     ls[now]=merge(ls[x],ls[y]);
     rs[now]=merge(rs[x],rs[y]);
     return now;
 }

 int main(){
     freopen("name.in","r",stdin);
     freopen("name.out","w",stdout);
     scanf("%s",s+); n=strlen(s+);
     S.init(); rep(i,,n) S.ext(s[i]-'a',i),ins(rt[S.lst],,n,i);
     rep(i,,S.nd) id[i]=i;
     sort(id+,id+S.nd+,cmp);
     for (int i=S.nd; i>; i--) rt[S.fa[id[i]]]=merge(rt[S.fa[id[i]]],rt[id[i]]);
     for (scanf("%d",&Q); Q--; ){
         scanf("%s%d%d",t+,&l,&r); m=strlen(t+);
         int now=,x=;
         T.init(); rep(i,,m) T.ext(t[i]-'a',i);
         rep(i,,m){
             int c=t[i]-'a';
             while (){
                 if (!que(rt[S.son[x][c]],,n,l+now,r)){
                     if (!now) break; now--;
                     if (now==S.mx[S.fa[x]]) x=S.fa[x];
                 }else{ now++; x=S.son[x][c]; break; }
             }
             len[i]=now;
         }
         ll ans=;
         rep(i,,T.nd) ans+=max(,T.mx[i]-max(T.mx[T.fa[i]],len[T.pos[i]]));
         printf("%lld\n",ans);
     }
     return ;
 }