bzoj4453

题意：
给你一个字符串，每次询问你一段区间的字典序最大的子串。
1<=|S|<=100000
1<=Q<=100000
1<=l<=r<=|S|

#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<cmath>
#include<iostream>
#include<vector>
#include<algorithm>
#define N 210000
#define maxd 16
#define pb push_back
using namespace std;
struct node{int x,rk,tim;}p[N];
struct node2{int l,r,id;}q[N];
int n,m,sa[N],rk[N],sum[N],y[N],w[N],h[N],f[N][18],r[N],tl;
int pl,ans[N],tim;
char s[N];
int rmq(int i,int j)
{
    int k=r[j-i+1];
    return min(f[i][k],f[j-(1<<k)+1][k]);
}
int lcp(int i,int j)
{
    i=rk[i];j=rk[j];
    if(i>j) swap(i,j);
    return rmq(i+1,j);
}
int get_tim(int i,int j)
{
    int k=lcp(i,j);
    return i+k;
}
struct node1{
    int l,r,lc,rc,head,siz;
    vector<node> v;
    void get_v()
    {
        pl=0;
        for(int i=l;i<=r;i++)
        {
            node t=(node){i,rk[i],0};
            if(pl==0) {p[++pl]=t;continue;}
            if(p[pl].rk>t.rk) continue;
            while(pl)
            {
                t.tim=get_tim(i,p[pl].x);
                if(t.tim<=p[pl].tim) pl--;
                else break;
            }
            p[++pl]=t;
        }
        for(int i=1;i<=pl;i++) v.pb(p[i]);
        siz=v.size()-1;
    }
    int ajust()
    {
        while(head<siz)
        {
            if(v[head+1].tim<=tim) head++;
            else break;
        }
        return v[head].x;
    }
}lt[N];
bool cmp(node2 x,node2 y)
{
    if(x.r<y.r) return 1;
    return 0;
}
bool cmp1(int i,int j,int k)
{
    return (y[i]!=y[j])||(y[i+k]!=y[j+k]);
}
void get_h()
{
    int k=0;
    for(int i=1;i<=n;i++)
    {
        int j=sa[rk[i]-1];
        if(k>0) k--;
        while(s[i+k]==s[j+k]) k++;
        h[rk[i]]=k;
    }
}
void get_sa()
{
    int m='z';
    for(int i=1;i<=n;i++) m=max(m,(int)s[i]);
    for(int i=1;i<=n;i++) rk[i]=s[i];
    for(int i=1;i<=n;i++) sum[rk[i]]++;
    for(int i=1;i<=m;i++) sum[i]+=sum[i-1];
    for(int i=n;i>=1;i--) sa[sum[rk[i]]--]=i;
    for(int i=1;i<=n;i++) y[i]=rk[i];
    int k=1;rk[sa[1]]=1;
    for(int i=2;i<=n;i++) 
        {if(cmp1(sa[i],sa[i-1],0)) k++;rk[sa[i]]=k;}
    for(int j=1;k<n;j*=2)
    {
        m=k;k=0;
        for(int i=n;i>=n-j+1;i--) y[++k]=i;
        for(int i=1;i<=n;i++) if(sa[i]>j) y[++k]=sa[i]-j;
        for(int i=1;i<=n;i++) w[i]=rk[y[i]];
        for(int i=1;i<=m;i++) sum[i]=0;
        for(int i=1;i<=n;i++) sum[w[i]]++;
        for(int i=1;i<=m;i++) sum[i]+=sum[i-1];
        for(int i=n;i>=1;i--) sa[sum[w[i]]--]=y[i];
        for(int i=1;i<=n;i++) y[i]=rk[i];
        k=1;rk[sa[1]]=1;
        for(int i=2;i<=n;i++)
            {if(cmp1(sa[i],sa[i-1],j)) k++;rk[sa[i]]=k;}
    }
    get_h();
}
void pre()
{
    r[1]=0;
    for(int i=2;i<=n;i++)
    {
        r[i]=r[i-1];
        if((1<<(r[i]+1))<i) r[i]++;
    }
    for(int i=n;i>=1;i--)
    {
        f[i][0]=h[i];
        for(int j=1;j<=maxd;j++)
        {
            if(i+(1<<j)-1>n) break;
            f[i][j]=min(f[i][j-1],f[i+(1<<(j-1))][j-1]);
        }
    }
}
void bt(int l,int r)
{
    int now=++tl;
    lt[now].l=l;lt[now].r=r;
    lt[now].get_v();
    if(l<r)
    {
        int mid=(l+r)/2;
        lt[now].lc=tl+1;bt(l,mid);
        lt[now].rc=tl+1;bt(mid+1,r);
    }
}
void init()
{
    scanf("%s",s+1);
    n=strlen(s+1);
    scanf("%d",&m);
    for(int i=1;i<=m;i++) {scanf("%d%d",&q[i].l,&q[i].r);q[i].id=i;}
    sort(q+1,q+m+1,cmp);
    get_sa();
    pre();
    bt(1,n);
}
int find(int now,int l,int r)
{
    int mid=(lt[now].l+lt[now].r)/2,lc=lt[now].lc,rc=lt[now].rc;
    if(lt[now].l==l && lt[now].r==r) return lt[now].ajust();
    if(mid>=r) return find(lc,l,r);
    else if(l>mid) return find(rc,l,r);
    else
    {
        int p1=find(lc,l,mid),p2=find(rc,mid+1,r);
        if(rk[p1]>rk[p2]) return p1;
        if(get_tim(p2,p1)>tim) return p1;
        return p2;
    }
}
void solve()
{
    for(int i=1;i<=m;i++)
    {
        tim=q[i].r;
        ans[q[i].id]=find(1,q[i].l,q[i].r);
    }
    for(int i=1;i<=m;i++) printf("%d\n",ans[i]);
}
int main()
{
    init();
    solve();
    return 0;
}

题解：
我的方法好复杂啊
先做出后缀数组，考虑离线按r从小到大做
先考虑对于单独一个询问，哪些位置可以成为答案？
显然是一个位置递增，rk也递增的队列。那么对于队列中的元素i，j(i< j)，什么时候j比i优呢？显然是询问的r>=j+lcp(s[i..n],s[j..n])的时候。我们把这个叫做j超越i的时间。
显然刚刚的队列，除了维护rk递增，再维护超越时间递增，随着r增大，答案是有单调性的。
由于询问是多个区间，我们开一棵线段树，每个节点储存对应区间的单调队列。询问[l,r]时就去log个对应区间找最优答案，再比较这log个答案就行了。
每个节点在线段树上只会出现log次，而询问的处理是有单调性的，所以复杂度O(n log n)。
看了一下题解，别人都是扫左端点的，因为这题的左右端点不等价根本注意不到T_T，扫左端点比较简单。
考虑左端点从右往左移，此时已经维护好了左端点为i+1的所有答案，只要知道左端点移动到i的影响就行了。
根据前面的结论，对于当前左端点，随着右端点递增，答案的位置和rk都是递增的。所以我们可以维护一个位置和rk递增的栈，记录这个元素在右端点为[l,r]时是答案。
对于栈顶rk小于rk[i]的，一直出栈，他的区间加入i的区间。碰到j(rk[j]>rk[i])时，j的区间要从[l,r]变为[max(l,j+lcp(s[i..n],s[j..n])),r]，将改变的这部分加入i的区间，如果j的区间全部变成了空，那让j出栈，继续比较下一个，否则break。
询问时二分即可。
简单的地方在于扫左端点时i点会超越哪些人是一次性的，而扫右端点时，i点会在多个右端点超越其他人。