loj#2720. 「NOI2018」你的名字

链接大合集：

loj

uoj

luogu

bzoj

单纯地纪念一下写的第一份5K代码。。。/躺尸

因为ZJOI都不会所以只好写NOI的题了。。。

总之字符串题肯定一上来就拼个大字符串跑后缀数组啦！

（为了便于说明，放一下样例的sa）

 #sbape#sgepe
 #sgepe
 #smape#sbape#sgepe
 amgepe#smape#sbape#sgepe
 ape#sbape#sgepe
 ape#sgepe
 bamgepe#smape#sbape#sgepe
 bape#sgepe
 cbamgepe#smape#sbape#sgepe
 e
 e#sbape#sgepe
 e#sgepe
 e#smape#sbape#sgepe
 epe
 epe#smape#sbape#sgepe
 gepe
 gepe#smape#sbape#sgepe
 mape#sbape#sgepe
 mgepe#smape#sbape#sgepe
 pe
 pe#sbape#sgepe
 pe#sgepe
 pe#smape#sbape#sgepe
 sbape#sgepe
 scbamgepe#smape#sbape#sgepe
 sgepe
 smape#sbape#sgepe

首先，对于每个T，考虑求出其子串总数。对于T每个后缀[i...|T|]，用st表求该后缀和它前面第一个T的后缀的lcp，则这个后缀的有效子串即为[i...j](j属于[i+lcp,|T|])。

（对于"sgepe"的后缀"epe"，lcp(10,14)=1,因此，其有效子串为"ep","epe"）

然后，我们再考虑去掉其有效子串中S[l...r]中的部分。

考虑64pts的部分分，即l=1,r=n。对于T的后缀[i...|T|]，只要求出L=max{lcp( T[i...|T|] , S[j...|S|] )}，我们就能算出每个后缀对答案的贡献。可以发现，这两个部分分别在区间上取min和max,即分别递增、递减，因此我们只要找到两个函数值最靠近的位置即可。

考虑100pts，我们可以离线做。按询问的l从大到小排序，每次在线段树上加入新的字符串使得线段树中的字符串为S[i...|S|](i>=l)。显然，i>r的字符串并不会对答案产生影响，于是我们就可以愉快地线段树上二分啦！（二分需要找到最近的满足递减函数小于递增函数的位置，在线段树上需要先上去再下来，总之写起来很恶心就对了。。。写了个人不人鬼不鬼的zkw线段树（好吧其实我并不怎么会zkw线段树。。。）总之这就是长达5k的原因。。。）

（啊，代码真丑。)

（不知道是不是因为大家都是sam而我是sa所以这么慢。。。）

（sa:所以自己常数大反而怪我咯？←_←）

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

 #define rep(i,l,r) for(int i=l;i<=r;++i)
 #define per(i,r,l) for(int i=r;i>=l;--i)
 #define pb push_back
 #define gc getchar()
 #define pc putchar

 typedef pair<int,int> pii;
 typedef long long ll;

 const int N=2e6+;

 int rd(){
     int x=;char c=gc;
     while(c<''||c>'') c=gc;
     while(c>=''&&c<=''){
         x=x*+c-'';
         c=gc;
     }

     return x;
 }

 void prt(ll x){
     if(x>) prt(x/);
     pc(x%+'');
 }

 //Q 查询字符串 l-r/r-l
 int L,n,m,sa[N];
 char s[N];

 namespace Sa{
     const int V=;
     int ht[N],ar[][N],*rk,*tp,ct[N],mx,ln,st[V+][N],lg[N];

     void get_sa(){
         rk=ar[];tp=ar[];

         rep(i,,n) ct[s[i]]++;
         rep(i,,) ct[i]+=ct[i-];
         rep(i,,n) sa[ct[s[i]]--]=i;
         rep(i,,n){
             if(s[sa[i]]!=s[sa[i-]]) ++mx;
             rk[sa[i]]=mx;
         }

         for(int k=;mx<n;k<<=){
             ln=;
             rep(i,n-k+,n) tp[++ln]=i;
             rep(i,,n) if(sa[i]>k) tp[++ln]=sa[i]-k;

             rep(i,,mx) ct[i]=;
             rep(i,,n) ct[rk[i]]++;
             rep(i,,mx) ct[i]+=ct[i-];
             per(i,n,) sa[ct[rk[tp[i]]]--]=tp[i];

             swap(tp,rk);
             mx=;
             rep(i,,n){
                 int I=sa[i],J=sa[i-];
                 if(tp[I]!=tp[J]||tp[min(I+k,n+)]!=tp[min(J+k,n+)]) ++mx;
                 rk[I]=mx;
             }
         }
     }

     void get_ht(){
         rep(i,,n) lg[i]=lg[i>>]+;

         rep(i,,n){//ht[rk[i]]
             if(rk[i]==) continue;
             int v=ht[rk[i-]];if(v>) v--;
             int J=sa[rk[i]-];
             while(s[i+v]==s[J+v]) v++;
             ht[rk[i]]=v;
         }

         rep(i,,n) st[][i]=ht[i];
         rep(j,,V) rep(i,,n)
             st[j][i]=min(st[j-][i],st[j-][min(i+(<<(j-)),n)]);
     }

     void init(){
         get_sa();
         get_ht();
     }

     int Q(int l,int r){
         if(l>r) swap(l,r);
         if(l==r) return L+;
         if(r>n) return ;
         l++;
         int j=lg[r-l+];
         return min(st[j][l],st[j][r-(<<j)+]);
     }
 }
 using Sa::Q;
 using Sa::rk;

 namespace Tr{
     const int M=(<<)-,H=(<<)-;
     int mi[M+],zuo[M+],you[M+];

     void build(){
         rep(i,H+,M){
             zuo[i]=you[i]=i-H;
             mi[i]=L+;
         }
         per(i,H,){
             zuo[i]=zuo[i<<];
             you[i]=you[i<<|];
             mi[i]=L+;
         }
     }

     void cg(int x,int val){
         x+=H;mi[x]=val;
         while(x!=){
             x>>=;
             mi[x]=min(mi[x],val);
         }
     }

     int rt,ctr;

     bool ck(int miv,int pos){
         return (rt+)<Q(pos,ctr)+miv;
         //即 (rt-miv+1)<Q(pos,ctr)
         //即 递减函数小于递增函数
     }

     int calc(int x){
         if(x==ctr) return ;
         return min(max(rt-mi[x+H]+,),Q(ctr,x));
     }

     int get_mi(int x,int oi){//oi=0 oi=1
         while((x<<)<M){
             if(mi[x<<|oi]<=rt) x=(x<<)|oi;
             else x=(x<<)|(oi^);
         }
         return x;
     }

     int Qr(int R,int C){//修改rt ctr
         rt=R;ctr=C;

         int ans=,x,miv,pos;

         x=ctr+H;miv=L+;
         while(x!=){
             x>>=;
             if(x&) continue;
             if(ck(min(miv,mi[x|]),you[x|])) miv=min(mi[x|],miv);
             else{
                 x|=;
                 break;
             }
         }
         while((x<<)<M){
             int ls=(x<<);
             if(ck(min(miv,mi[ls]),you[ls])){
                 miv=min(miv,mi[ls]);
                 x=(x<<|);
             }
             else x=ls;
         }
         pos=x-H;

         ans=max(calc(pos),ans);
         //往左的第一个 mi[pos]<=rt
         while(x!=){
             if(x&){
                 if(mi[x^]<=rt){
                     x=x^;
                     break;
                 }
             }
             x>>=;
         }
         pos=get_mi(x,)-H;
         ans=max(calc(pos),ans);

         x=ctr+H;miv=L+;
         while(x!=){
             x>>=;
             if(x&){
                 if(ck(min(miv,mi[x^]),zuo[x^])) miv=min(miv,mi[x^]);
                 else{
                     x^=;
                     break;
                 }
             }
         }
         while((x<<)<M){
             int rs=(x<<|);
             if(ck(min(miv,mi[rs]),zuo[rs])){
                 miv=min(miv,mi[rs]);
                 x=(x<<);
             }
             else x=rs;
         }
         pos=x-H;

         ans=max(calc(pos),ans);
         //往右第一个
         while(x!=){
             if((x&)==){
                 if(mi[x|]<=rt){
                     x|=;
                     break;
                 }
             }
             x>>=;
         }
         pos=get_mi(x,)-H;

         ans=max(calc(pos),ans);

         return ans;
     }
 }
 using Tr::cg;
 using Tr::Qr;

 struct Query{
     int l,r,no;
 }a[N];
 bool cmp(Query aa,Query bb){
     return aa.l>bb.l;
 }
 vector<int> ps[N];
 int hd[N],no[N],bg[N];

 typedef long long ll;
 ll ans[N];

 int main(){
     scanf("%s",s+);
     L=n=strlen(s+);

     m=rd();
     rep(i,,m){
         s[++n]='#';
         scanf("%s",s++n);
         bg[i]=n;
         n+=strlen(s++n);

         rep(j,bg[i]+,n) hd[j]=i,no[j]=n-j+;
         a[i]=(Query){rd(),rd(),i};
     }

     Sa::init();

     rep(i,,n){
         rep(j,sa[i],n) cerr<<s[j];
         cerr<<endl;
     }

     rep(i,,n) ps[hd[sa[i]]].pb(i);

     sort(a+,a++m,cmp);
     Tr::build();
     int R=L;
     rep(i,,m){
         while(a[i].l<=R) cg(rk[R],R) ,R--;
         rep(j,,ps[a[i].no].size()-){
             int lcp=,pos=ps[a[i].no][j];
             if(j) lcp=Q(pos,ps[a[i].no][j-]);
             lcp=max(lcp,Qr(a[i].r,pos));

             if(no[sa[pos]]>lcp) ans[a[i].no]+=no[sa[pos]]-lcp;
         }
     }

     rep(i,,m) printf("%lld\n",ans[i]);
     return ;
 }
 //得到sa ht st存ht
 //vector存每个询问的位置

 //l从大到小对询问排序
 //处理T的重复子串
 //线段树加点 线段树上二分最小值