[BZOJ3065]带插入区间K小值-替罪羊树-权值线段树

带插入区间K小值

Description

从前有n只跳蚤排成一行做早操，每只跳蚤都有自己的一个弹跳力a[i]。跳蚤国王看着这些跳蚤国欣欣向荣的情景，感到非常高兴。这时跳蚤国王决定理性愉悦一下，查询区间k小值。他每次向它的随从伏特提出这样的问题: 从左往右第x个到第y个跳蚤中，a[i]第k小的值是多少。
这可难不倒伏特，他在脑袋里使用函数式线段树前缀和的方法水掉了跳蚤国王的询问。
这时伏特发现有些跳蚤跳久了弹跳力会有变化，有的会增大，有的会减少。
这可难不倒伏特，他在脑袋里使用树状数组套线段树的方法水掉了跳蚤国王的询问。（orz 主席树）
这时伏特发现有些迟到的跳蚤会插入到这一行的某个位置上，他感到非常生气，因为……他不会做了。
请你帮一帮伏特吧。
快捷版题意：带插入、修改的区间k小值在线查询。

Input

第一行一个正整数n，表示原来有n只跳蚤排成一行做早操。
第二行有n个用空格隔开的非负整数，从左至右代表每只跳蚤的弹跳力。
第三行一个正整数q，表示下面有多少个操作。
下面一共q行，一共三种操作对原序列的操作：（假设此时一共m只跳蚤）
1. Q x y k: 询问从左至右第x只跳蚤到从左至右第y只跳蚤中，弹跳力第k小的跳蚤的弹跳力是多少。
(1 <= x <= y <= m, 1 <= k <= y - x + 1)
2. M x val: 将从左至右第x只跳蚤的弹跳力改为val。
(1 <= x <= m)
3. I x val: 在从左至右第x只跳蚤的前面插入一只弹跳力为val的跳蚤。即插入后从左至右第x只跳蚤是我刚插入的跳蚤。
(1 <= x <= m + 1)

为了体现在线操作，设lastAns为上一次查询的时候程序输出的结果，如果之前没有查询过，则lastAns = 0。
则输入的时候实际是：
Q _x _y _k ——> 表示 Q _x^lastAns _y^lastAns _k^lastAns
M _x _val ——> 表示 M _x^lastAns _val^lastAns
I _x _val ——> 表示 I _x^lastAns _val^lastAns
简单来说就是操作中输入的整数都要异或上一次询问的结果进行解码。

(祝Pascal的同学早日转C++，就不提供pascal版的描述了。)

Output

对于每个询问输出回答，每行一个回答。

Sample Input

10
10 5 8 28 0 19 2 31 1 22
30
I 6 9
M 1 11
I 8 17
M 1 31
M 6 26
Q 2 7 6
I 23 30
M 31 7
I 22 27
M 26 18
Q 26 17 31
I 5 2
I 18 13
Q 3 3 3
I 27 19
Q 23 23 30
Q 5 13 5
I 3 0
M 15 27
Q 0 28 13
Q 3 29 11
M 2 8
Q 12 5 7
I 30 19
M 11 19
Q 17 8 29
M 29 4
Q 3 0 12
I 7 18
M 29 27

Sample Output

28
2
31
0
14
15
14
27
15
14

HINT

此题作为一个小小的研究来搞吧～做法有很多～不知道这题究竟有多少种做法。

请自觉O(log^2n)，我故意卡块状链表，块链A了的请受我深情一拜……

A掉的同学请在Discuss里面简要说下自己的做法吧～

原序列长度 <= 35000

插入个数 <= 35000，修改个数 <= 70000，查询个数 <= 70000 ,0 <= 每时每刻的权值 <= 70000

由于是OJ上的题，所以数据无梯度。为了防止卡OJ，本题只有4组数据。

Source

作者 vfleaking

---

作者在经过长达一天加一个上午的调试后已濒临崩溃
因此以下内容可能有错误，若发现请指出。

---

思路:
神题。
虽然很快就能有一大堆思路，但咱是来练习写替罪羊树的，因此考虑替罪羊树的做法。

把序列按中序遍历建到一棵替罪羊树上，每个节点维护一棵权值线段树（不是主席树!!!），用于存放子树内所有节点的信息。

对于插入和修改，考虑维护每个节点的子树大小以记录当前节点在原树中的位置。
每次插入或修改在树上二分找到位置，并回溯修改所有祖先节点即可。
当插入后发现不满足大小平衡时，采用二分法重建，将所有原有的权值线段树拍扁重新一个个插入。

查询时，考虑将所有询问区间包含的权值线段树根节点和一些单个节点放到一起二分即可。

由于空间开不下，需要内存池与垃圾回收系统。

然后，下面的这份代码实现很长。

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

inline int read()
{
    int x=0;char ch=getchar();
    while(ch<'0' || '9'<ch)ch=getchar();
    while('0'<=ch && ch<='9')x=x*10+(ch^48),ch=getchar();
    return x;
}

inline void write(int x)
{
    if(x>=10)write(x/10);
    putchar('0'+x%10);
}

const int N=70009;
const int M=10000009;
const int m=70000;

int n,q,lans;
int v[N];

namespace segtree
{
    int ls[M],rs[M],t[M],top;
    vector<int> stk;

    inline int newnode()
    {
        if(!stk.size())
            return ++top;
        else
        {
            int ret=stk.back();stk.pop_back();
            return ret;
        }
    }

    inline void free(int &x)
    {
        if(!x)return;
        stk.push_back(x);
        free(ls[x]);
        free(rs[x]);
        t[x]=0;x=0;
    }

    inline int cp(int x,int y)
    {
        t[x]=t[y];ls[x]=ls[y];rs[x]=rs[y];
    }

    inline void modify(int &now,int l,int r,int p,int v)
    {
        if(!now)now=newnode();
        t[now]+=v;
        if(l==r)return;
        int mid=l+r>>1;
        if(p<=mid)
            modify(ls[now],l,mid,p,v);
        else
            modify(rs[now],mid+1,r,p,v);
        if(!t[now])free(now);
    }

}

namespace scapegoat
{
    const double alpha=0.75;
    int root,rt[N<<2],ch[N<<2][2];
    int siz[N<<2],t[N<<2],tot;
    int stk[N<<2],top,vstk[N<<2],vtop,mem;

    inline void getseq(int x)
    {
        if(ch[x][0])getseq(ch[x][0]);
        stk[++top]=x;
        if(ch[x][1])getseq(ch[x][1]);
    }

    inline int build(int l,int r)
    {
        if(l>r)return 0;
        if(l==r)
        {
            int now=stk[l];
            siz[now]=1;
            segtree::free(rt[now]);
            ch[now][0]=ch[now][1]=0;
            segtree::modify(rt[now],0,m,t[now],1);
            return now;
        }
        int mid=l+r>>1,now=stk[mid];
        ch[now][0]=build(l,mid-1);
        ch[now][1]=build(mid+1,r);
        segtree::free(rt[now]);
        for(int i=l;i<=r;i++)
            segtree::modify(rt[now],0,m,t[stk[i]],1);
        siz[now]=r-l+1;
        return now;
    }

    inline void rebuild(int &scapegoats)
    {
        top=0;getseq(scapegoats);
        scapegoats=build(1,top);
    }

    inline void insert(int &now,int pos,int val)
    {
        if(!now)
        {
            now=++tot;
            segtree::modify(rt[now],0,m,val,1);
            t[now]=val;siz[now]=1;
            return;
        }
        segtree::modify(rt[now],0,m,val,1);
        siz[now]++;
        int lsiz=siz[ch[now][0]];
        if(pos<=lsiz)
            insert(ch[now][0],pos,val);
        else
            insert(ch[now][1],pos-lsiz-1,val);
        if(siz[now]*alpha>max(siz[ch[now][0]],siz[ch[now][1]]))
        {
            if(mem)
            {
                if(ch[now][0]==mem)
                    rebuild(ch[now][0]);
                else
                    rebuild(ch[now][1]);
                mem=0;
            }
        }
        else
            mem=now;
    }

    inline int modify(int x,int p,int l,int r,int val)
    {
        int mid=l+r>>1,sonv;
        if(siz[ch[x][0]]+1==p)
        {
            segtree::modify(rt[x],0,m,t[x],-1);
            segtree::modify(rt[x],0,m,val,1);
            return x;
        }
        if(siz[ch[x][0]]>=p)
            sonv=modify(ch[x][0],p,l,mid,val);
        else
            sonv=modify(ch[x][1],p-siz[ch[x][0]]-1,mid+1,r,val);
        segtree::modify(rt[x],0,m,t[sonv],-1);
        segtree::modify(rt[x],0,m,val,1);
        return sonv;
    }

    inline void getqseq(int x,int l,int r)
    {
        if(l==1 && r==siz[x]){stk[++top]=rt[x];return;}
        int lsiz=siz[ch[x][0]];
        if(l<=lsiz+1 && lsiz+1<=r)
            vstk[++vtop]=t[x];
        if(r<=lsiz)
            getqseq(ch[x][0],l,r);
        else if(lsiz+1<l)
            getqseq(ch[x][1],l-lsiz-1,r-lsiz-1);
        else
        {
            if(l<=lsiz)
                getqseq(ch[x][0],l,lsiz);
            if(lsiz+1<r)
                getqseq(ch[x][1],1,r-lsiz-1);
        }
    }

    inline int query(int dl,int dr,int kth)
    {
        using segtree::ls;using segtree::rs;
        top=vtop=0;getqseq(root,dl,dr);
        int l=0,r=m,mid,sum;kth--;
        while(l<r)
        {
            mid=l+r>>1;sum=0;
            for(int i=1;i<=top;i++)
                sum+=segtree::t[ls[stk[i]]];
            for(int i=1;i<=vtop;i++)
                sum+=(l<=vstk[i] && vstk[i]<=mid);
            if(kth<sum)
            {
                for(int i=1;i<=top;i++)
                    stk[i]=ls[stk[i]];
                r=mid;
            }
            else
            {
                for(int i=1;i<=top;i++)
                    stk[i]=rs[stk[i]];
                l=mid+1;kth-=sum;
            }
        }
        return l;
    }
}

using namespace scapegoat;

int main()
{
    n=read();
    for(int i=1;i<=n;i++)
        v[i]=read();
    for(int i=1;i<=n;i++)
        stk[i]=++tot,t[i]=v[i];
    root=build(1,top=n);

    q=read();char s[10];
    for(int i=1,a,b,c;i<=q;i++)
    {
        scanf("%s",s+1);
        if(s[1]=='Q')
        {
            a=read()^lans;b=read()^lans;c=read()^lans;
            write(lans=query(a,b,c));putchar('\n');
        }
        else if(s[1]=='M')
        {
            a=read()^lans;b=read()^lans;
            t[modify(root,a,0,m,b)]=b;;
        }
        else
        {
            a=read()^lans;b=read()^lans;
            mem=0;insert(root,a-1,b);
            if(mem){mem=0;rebuild(root);}
        }
    }

    return 0;
}