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+3;

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

    return x;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    int rt,ctr;

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

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

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


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


        int ans=0,x,miv,pos;

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


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

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

        ans=max(calc(pos),ans);
        //往右第一个
        while(x!=1){
            if((x&1)==0){
                if(mi[x|1]<=rt){
                    x|=1;
                    break;
                }
            }
            x>>=1;
        }
        pos=get_mi(x,0)-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+1);
    L=n=strlen(s+1);

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

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

    Sa::init();

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

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

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

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

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

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