BZOJ3065 带插入区间K小值

推荐学习WJMZBMR《重量平衡树和后缀平衡树在信息学奥赛中的应用》

转自hzwer：

在替罪羊树每个结点放一棵包含该子树所有结点的权值线段树，也就是平衡树套权值线段树

1、由于外层是平衡树，那么就能实现插入一个结点：找到它的位置，在根到其路径上所有结点的线段树中插入这个值

2、查询区间第K大：找到这个区间包含若干棵子树，拿出他们的根的权值线段树，一起做个二分

3、修改与插入类似

4、当外层平衡树失衡的时候重构之，将某个子树自下而上线段树合并

然后就是考验数据结构的能力了QAQ

由于内存不够，我们还需要回收垃圾，即对数组的重复使用

自己又加了许多的备注

#include<bits/stdc++.h>
#define alpha 0.75
using namespace std;
const int N=7e4+10,M=1e7+10;
int tmp,n,m,sz,ans,root;
int v[N],dfn[N],rt[N],ls[N],rs[N];
struct node{
    int l,r,s;
}t[M];
vector<int>rec,a,p;
int L=0,R=70000;//所谓权值线段树即是将点的权值作为线段树的下标
inline int newnode()
{
    if(!rec.size())
    return ++sz;
    else{
        int k=rec.back();rec.pop_back();
        return k;
    }//循环利用 
}
void reclaim(int &x)
{
    if(!x)return;
    rec.push_back(x);
    reclaim(t[x].l);reclaim(t[x].r);//清除权值线段树 
    t[x].s=0;x=0;
}
void insert(int &k,int l,int r,int pos,int f)
{
    if(!k)k=newnode();
    if(l==r){t[k].s+=f;return;}
    int mid=l+r>>1;
    if(pos<=mid)insert(t[k].l,l,mid,pos,f);
    else insert(t[k].r,mid+1,r,pos,f);
    t[k].s=t[t[k].l].s+t[t[k].r].s;
    if(!t[k].s)reclaim(k);//如果这个大小没有数我们就将它回收利用 
}
void build(int &k,int l,int r)
{
    if(l>r)return;
    if(l==r){
        k=dfn[l];
        insert(rt[k],L,R,v[k],1);//构造权值线段树 
        return;
    }
    int mid=l+r>>1;k=dfn[mid];
    build(ls[k],l,mid-1);build(rs[k],mid+1,r);
    for(int i=l;i<=r;++i)
    insert(rt[k],L,R,v[dfn[i]],1);//对每颗子树建权值线段树 
}
void del(int &x)
{
    if(!x)return;
    reclaim(rt[x]);
    del(ls[x]);p.push_back(x);del(rs[x]);//清除每个点的权值线段树 
    x=0;
}
void rebuild(int &x)
{
    del(x);int s1=p.size();
    for(int i=1;i<=s1;++i)
    dfn[i]=p[i-1];//中序遍历后将值重新分配
    build(x,1,s1);//暴力重构 
    p.clear();
}
int modify(int k,int x,int w)
{
    insert(rt[k],L,R,w,1);//修改路径上每颗子树 
    int LS=t[rt[ls[k]]].s,last;
    if(LS+1==x){last=v[k];v[k]=w;}
    else if(LS>=x)last=modify(ls[k],x,w);
    else last=modify(rs[k],x-LS-1,w);
    insert(rt[k],L,R,last,-1);//将原来的删去 
    return last;
}
void get(int k,int l,int r)//此时l，r不同于平时的区间而是指的是在k的线段树中大小为l~r这一段 
{
    int LS=t[rt[ls[k]]].s,SUM=t[rt[k]].s;
    if(l==1&&r==SUM)//如果指的整颗子树
    {a.push_back(rt[k]);return;} 
    if(l<=LS+1&&r>=LS+1)p.push_back(v[k]);//如果单独是这一个点
    if(r<=LS)get(ls[k],l,r);
    else if(l>LS+1)get(rs[k],l-LS-1,r-LS-1);
    else{//分跨两边，此时中间点已经拿走 
        if(l<=LS)get(ls[k],l,LS);
        if(SUM>LS+1)get(rs[k],1,r-LS-1); 
    } 
}
int query(int l,int r,int k)
{
    get(root,l,r);//找出这区间中的所有子树
    int s1=a.size(),s2=p.size();k--;
    l=L,r=R;
    while(l<r)
    {
        int mid=l+r>>1,sum=0;
        for(int i=0;i<s1;++i)sum+=t[t[a[i]].l].s;
        for(int i=0;i<s2;++i)
        if(p[i]>=l&&p[i]<=mid)sum++;
        if(sum>k){
            for(int i=0;i<s1;++i)a[i]=t[a[i]].l;
            r=mid;
        }
        else{
            for(int i=0;i<s1;++i)a[i]=t[a[i]].r;
            l=mid+1;k-=sum;
        }
    }
    a.clear();p.clear();
    return l;
}
void insert(int &k,int x,int w)
{
    if(!k)
    {
        k=++n;
        insert(rt[k],L,R,w,1);
        v[k]=w;
        return;
    }
    insert(rt[k],L,R,w,1);
    int LS=t[rt[ls[k]]].s;
    if(LS>=x)insert(ls[k],x,w);
    else insert(rs[k],x-LS-1,w);
    if(t[rt[k]].s*alpha>max(t[rt[ls[k]]].s,t[rt[rs[k]]].s))//满足
    {
        if(tmp)
        {
            if(ls[k]==tmp)rebuild(ls[k]);
            else rebuild(rs[k]);
            tmp=0;
        }
    }
    else tmp=k;//不满足 
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;++i)scanf("%d",&v[i]);
    for(int i=1;i<=n;++i)dfn[i]=i;
    build(root,1,n);//构造替罪羊树
    scanf("%d",&m);char ch[10];int x,y,k;
    for(int i=1;i<=m;++i)
    {
        scanf("%s",ch);
        scanf("%d%d",&x,&y);x^=ans;y^=ans;
        if(ch[0]=='Q')
        {
            scanf("%d",&k);k^=ans;
            ans=query(x,y,k);printf("%d\n",ans);
        }
        else if(ch[0]=='M')
        {
            modify(root,x,y);
        }
        else
        {
            tmp=0;insert(root,x-1,y);
            if(tmp){tmp=0;rebuild(root);}//重构整颗树 
        }
    }
    return 0;
}