bzoj 3065 带插入区间K小值 重量平衡treap套主席树

题意：维护一个数列，支持插入，修改，查询区间k小值。

我数据结构还是太弱呀QAQ
看了myy的课件和vfk的题解

treap支持重量平衡，也就是他插入删除影响的节点数都是$O(log)$ 的。

先说插入，我们先把点插入到最下面，然后往上旋，假设这个点转到祖先k的位置，那么影响节点为$size_k$ 个，由于这个点的随机权值是$size_k$ 个点中最小的，这个的概率是$\frac{1}{size_k}$ 的。期望是$O(1)$，一个点有$O(log)$ 个祖先，因此总期望影响节点数$O(log)$

对于删除，由于treap形态是由随机权值决定的，因此删除的数在treap上位置是随机的。由于treap中一个点的子树的期望大小是$O(log)$ 的。因此是$O(log)$ 的。

treap插入一个元素旋转的期望次数是$O(1)$ 的。因为他的随机权值必须比上面的随机权值大才会旋转，这个次数期望$O(1)$

前面是几个保证复杂度的东西。

treap每个点代表一个数列中的点。每个点开一棵权值线段树维护子树中的所有点的权值。

由于旋转次数期望$O(1)$，因此可以每次旋转之后直接更新一下信息，不需要最后重构子树里的线段树。
旋转x时，设y是x的父亲，那么旋转后x的线段树和旋转前y的线段树相同，只需更新一下y的线段树。

一开始想用$O(log)$ 的线段树合并，不过线段树合并不支持内存回收，可能MLE，因此写了一个合并到底的$O(log^2)$ 。

查询时用前缀和相减的方法，可以得到$log$ 个线段树或点。在主席树上二分一下时间复杂度$O(log^2)$

学完splay和fhq treap后觉得普通treap已经完全没有用了，不过treap重量平衡的性质还是非常妙的。

好像常数巨大。。。。附上3.7K代码

#include <bits/stdc++.h>
using namespace std;
#define N 71000
#define M 25000000
#define S 70000
#define which(x) ch[fa[x]][1]==x
#define ls ch[x][0]
#define rs ch[x][1]
struct node
{
    int tp1,tp2,x;
    node(){}
    node(int tp1,int tp2,int x):tp1(tp1),tp2(tp2),x(x){}
}st[N];
int top,n,q,a[N];
char s[11];
struct seg_tree
{
    int ch[M][2],sum[M],cnt;
    queue<int>que;
    int ap()
    {
        if(que.empty())return ++cnt;
        int ret=que.front();que.pop();
        ch[ret][1]=ch[ret][0]=0;sum[ret]=0;
        return ret;
    }
    void insert(int l,int r,int &x,int v,int type)
    {
        if(!x)x=ap();sum[x]+=type;
        if(l==r)return;
        int mid=(l+r)>>1;
        if(v<=mid)insert(l,mid,ch[x][0],v,type);
        else insert(mid+1,r,ch[x][1],v,type);
    }
    void insert(int &x,int v,int type)
    {insert(0,S,x,v,type);}
    int merge(int x,int y)
    {
        if(!x&&!y)return 0;
        int ret=ap();
        ch[ret][0]=merge(ch[x][0],ch[y][0]);
        ch[ret][1]=merge(ch[x][1],ch[y][1]);
        sum[ret]=sum[x]+sum[y];
        return ret;
    }
    void del(int x)
    {
        if(!x)return;
        que.push(x);
        del(ls);del(rs);
    }
    int work(int l,int r,int x)
    {
        if(l==r)return l;
        int t=0,mid=(l+r)>>1;
        for(int i=1;i<=top;i++)
        {
            if(st[i].tp2==1)t+=sum[ch[st[i].x][0]]*st[i].tp1;
            else if(st[i].x<=mid&&st[i].x>=l)t+=st[i].tp1;
        }
        if(t>=x)
        {
            for(int i=1;i<=top;i++)
                if(st[i].tp2==1)st[i].x=ch[st[i].x][0];
            return work(l,mid,x);
        }
        else
        {   
            for(int i=1;i<=top;i++)
                if(st[i].tp2==1)st[i].x=ch[st[i].x][1];
            return work(mid+1,r,x-t);
        }
    }
}tr1;
struct treap
{
    int ch[N][2],rt[N],size[N],rnd[N],root,cnt,fa[N],val[N];
    void pushup(int x)
    {
        size[x]=size[ls]+size[rs]+1;
        rt[x]=tr1.merge(rt[ls],rt[rs]);
        tr1.insert(rt[x],val[x],1);
    }
    int build(int l,int r)
    {
        if(l>r)return 0;
        int mid=(l+r)>>1,x=++cnt;
        val[x]=a[mid];rnd[x]=rand()*rand();
        ch[x][0]=build(l,mid-1);
        ch[x][1]=build(mid+1,r);
        pushup(x);
        return x;
    }
    int rotate(int x)
    {
        int y=fa[x],k=which(x);
        ch[y][k]=ch[x][k^1];ch[x][k^1]=y;
        ch[fa[y]][which(y)]=x;

        fa[x]=fa[y];fa[y]=x;
        fa[ch[y][k]]=y;

        tr1.del(rt[x]);rt[x]=rt[y];
        pushup(y);
        size[x]=size[ls]+size[rs]+1;
        return x;
    }
    int insert(int x,int pos,int v)
    {
        if(!x)
        {
            x=++cnt;tr1.insert(rt[x],v,1);
            size[x]=1;rnd[x]=rand()*rand();
            val[x]=v;
            return x;   
        }
        if(pos<=size[ls])
        {
            tr1.insert(rt[x],v,1);size[x]++;
            ls=insert(ls,pos,v);fa[ls]=x;
            if(rnd[ls]>rnd[x])x=rotate(ls);
        }
        else
        {
            tr1.insert(rt[x],v,1);size[x]++;
            rs=insert(rs,pos-size[ls]-1,v);fa[rs]=x;
            if(rnd[rs]>rnd[x])x=rotate(rs);
        }
        return x;
    }
    int change(int x,int pos,int v)
    {
        if(size[ls]+1==pos)
        {
            tr1.insert(rt[x],val[x],-1);
            tr1.insert(rt[x],v,1);
            return x;
        }
        int t;
        if(size[ls]>=pos)t=change(ls,pos,v);
        else t=change(rs,pos-size[ls]-1,v);
        tr1.insert(rt[x],val[t],-1);
        tr1.insert(rt[x],v,1);
        return t;
    }
    void find(int x,int pos,int tp)
    {
        if(!x||!pos)return;
        if(size[x]==pos)
            st[++top]=node(tp,1,rt[x]);
        else if(size[ls]>=pos)
            find(ls,pos,tp);
        else
        {
            st[++top]=node(tp,1,rt[ls]);
            st[++top]=node(tp,0,val[x]);
            find(rs,pos-size[ls]-1,tp);
        }
    }
}tr2;
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    tr2.root=tr2.build(1,n);
    scanf("%d",&q);
    for(int x,y,k,val,ans=0;q--;)
    {
        scanf("%s",s);
        if(s[0]=='Q')
        {
            scanf("%d%d%d",&x,&y,&k);
            x^=ans;y^=ans;k^=ans;
            top=0;
            tr2.find(tr2.root,x-1,-1);
            tr2.find(tr2.root,y,1);
            ans=tr1.work(0,S,k);
            printf("%d\n",ans);
        }
        if(s[0]=='M')
        {
            scanf("%d%d",&x,&val);
            x^=ans;val^=ans;
            int t=tr2.change(tr2.root,x,val);
            tr2.val[t]=val;
        }
        if(s[0]=='I')
        {
            scanf("%d%d",&x,&val);
            x^=ans;val^=ans;
            tr2.root=tr2.insert(tr2.root,x-1,val);
        }
    }
    return 0;
}