[bzoj3682]Phorni

题目大意

给你一个字符串，初始长度为len，还有一个n个元素的序列P。接下来m个操作，有三种类型，分别是：
1. 在字符串前面加入一个字符
2. 修改P中一个元素的值
3. 询问对于所有i∈[l,r]，S[L-P[i]+1..L]字典序最小的i（有多个则输出最小的i，L是当前字符串长度）

Data Constraint

对于 100% 的数据, 1≤n≤500000, 1≤m≤800000,1≤Pi≤len≤ 100000。
修改操作中 1 ≤ x ≤ n, 1 ≤ pos ≤ 当前字符串长度。
询问操作中 1 ≤ l, r ≤ n,插入操作数量约占总操作数量的 1/5,修改、询问操作数量约各占总操作数量的2/5。

分析

首先要考虑维护每个后缀的排名，然后还要是在线的算法，支持在线插入。这个是后缀数组、后缀自动机难以实现的。
所以可以考虑使用后缀平衡树。

如果使用后缀平衡树，那么这就是裸题。用线段树维护P数组区间最小的后缀。由于只有插入操作，刚刚执行插入一个新后缀的操作后，P数组没有一个元素和这个后缀对应，所以不用给线段树做任何操作。
修改和询问就是简单的线段树操作了。
时间复杂度$O(mlogn)$

/**************************************************************
    Problem: 3682
    User: worldwide
    Language: C++
    Result: Accepted
    Time:16316 ms
    Memory:40072 kb
****************************************************************/

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>

using namespace std;

const int maxn=800005,maxt=1048585,mo=5371297,pri=832189;

typedef long long LL;

const LL inf=(LL)1<<61;

int n,m,root,fa[maxn],son[maxn][2],fix[maxn],len,typ,p[maxn],t[maxt],ans;

LL l[maxn],r[maxn],rank[maxn];

char c,s[maxn];

int read()
{
    for (c=getchar();c<'0' || c>'9';c=getchar());
    int x=c-48;
    for (c=getchar();c>='0' && c<='9';c=getchar()) x=x*10+c-48;
    return x;
}

void rebuild(int x,LL L,LL R)
{
    if (!x) return;
    l[x]=L; r[x]=R; rank[x]=(l[x]+r[x])/2;
    rebuild(son[x][0],l[x],rank[x]);
    rebuild(son[x][1],rank[x],r[x]);
}

void Rotate(int x,int t,LL l,LL r)
{
    int y=fa[x];
    if (y==root) root=x;else
    {
        if (son[fa[y]][0]==y) son[fa[y]][0]=x;else son[fa[y]][1]=x;
    }
    fa[x]=fa[y];
    son[y][t]=son[x][t^1]; fa[son[y][t]]=y; son[x][t^1]=y; fa[y]=x;
    rebuild(x,l,r);
}

bool cmp(int x,int y)
{
    return s[x]<s[y] || s[x]==s[y] && rank[x-1]<rank[y-1];
}

void insert(int i,int x,LL l,LL r)
{
    LL mid=l+r>>1;
    if (cmp(x,i))
    {
        if (son[i][0]) insert(son[i][0],x,l,mid);
        else
        {
            son[i][0]=x; fa[x]=i; rebuild(x,l,mid);
        }
        if (fix[i]>fix[son[i][0]]) Rotate(son[i][0],0,l,r);
    }else
    {
        if (son[i][1]) insert(son[i][1],x,mid,r);
        else
        {
            son[i][1]=x; fa[x]=i; rebuild(x,mid,r);
        }
        if (fix[i]>fix[son[i][1]]) Rotate(son[i][1],1,l,r);
    }
}

void change(int l,int r,int g,int x)
{
    if (l==r)
    {
        t[x]=l; return;
    }
    int mid=l+r>>1;
    if (g<=mid) change(l,mid,g,x<<1);else change(mid+1,r,g,(x<<1)|1);
    if (rank[p[t[x<<1]]]<=rank[p[t[(x<<1)|1]]]) t[x]=t[x<<1];else t[x]=t[(x<<1)|1];
}

int query(int l,int r,int a,int b,int x)
{
    if (l==a && r==b) return t[x];
    int mid=l+r>>1;
    if (b<=mid) return query(l,mid,a,b,x<<1);
    if (a>mid) return query(mid+1,r,a,b,(x<<1)|1);
    int P=query(l,mid,a,mid,x<<1),Q=query(mid+1,r,mid+1,b,(x<<1)|1);
    if (rank[p[P]]<=rank[p[Q]]) return P;
    return Q;
}

int main()
{
    n=read(); m=read(); len=read(); typ=read();
    scanf("%s",s+1);
    for (int i=1;i<=len/2;i++)
    {
        s[i]^=s[len-i+1]^=s[i]^=s[len-i+1];
    }
    root=1;
    l[1]=0; r[1]=inf; rank[1]=inf>>1;
    fix[1]=(LL)s[1]*pri%mo;
    for (int i=2;i<=len;i++) insert(root,i,0,inf);
    for (int i=1;i<=n;i++)
    {
        p[i]=read(); change(1,n,i,1);
    }
    while (m--)
    {
        for (;c!='I' && c!='C' && c!='Q';c=getchar());
        if (c=='I')
        {
            char t=read();
            if (typ) t^=ans;
            s[++len]=t+'a';
            insert(root,len,0,inf);
        }else if (c=='C')
        {
            int x=read();
            p[x]=read();
            change(1,n,x,1);
        }else
        {
            int l=read(),r=read();
            ans=query(1,n,l,r,1);
            printf("%d\n",ans);
        }
    }
    return 0;
}