2018.10.03 【模板】替罪羊树

最新推荐文章于 2023-11-03 11:23:52 发布

SC.ldxcaicai

最新推荐文章于 2023-11-03 11:23:52 发布

阅读量194

点赞数 1

分类专栏： # 替罪羊树文章标签：数据结构

本文链接：https://blog.csdn.net/dreaming__ldx/article/details/82934123

版权

替罪羊树专栏收录该内容

1 篇文章 0 订阅

订阅专栏

替罪羊树是基于常数alpha的重量平衡树，当子树大小超过父节点的alpha倍时，进行拍扁重建操作，将其转换为极度平衡的二叉树。此树结构稳定，不依赖旋转，适合作为外层嵌套的平衡树。实现中需关注内存池管理。

摘要由CSDN通过智能技术生成

替罪羊树是一种很暴力的重量平衡树，实现原理就是维护一个常数 $a l p h a$ ，当 $s i z e [s o n] > = s o n [r o o t] * a l p h a$ 时，直接将不满足这一性质的子树拍扁重建。
拍扁重建：先将整颗子树变成线性的链表式结构，然后递归建出一棵极度平衡的二叉树。
另外，由于是重量平衡树，表示替罪羊树的结构十分稳定，而且因为不用旋转，替罪羊树是除了 $fhq_treap$ 之外又一种可以支持在外层用于嵌套的平衡树。
实现细节：注意内存池的回收。
代码（普通平衡树）：

#include<bits/stdc++.h>
#define lc (son[p][0])
#define rc (son[p][1])
using namespace std;
inline int read(){
    int ans=0,w=1;
    char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')w=-1;ch=getchar();}
    while(isdigit(ch))ans=(ans<<3)+(ans<<1)+(ch^48),ch=getchar();
    return ans*w;
}
struct SGT{
    static const int N=100005;
    static const double alpha=0.75;
    int st[N],top,tot,rt,son[N][2],fa[N],val[N],siz[N],all[N];
    bool in[N];
    inline int get(){return top?st[top--]:++tot;}
    void del(int t){st[++top]=t;}
    inline void pushup(int p){siz[p]=siz[lc]+siz[rc]+in[p],all[p]=all[lc]+all[rc]+1;}
    inline bool check(int p){return (all[lc]>=all[p]*alpha)||(all[rc]>=all[p]*alpha);}
    inline int newnode(int v=0,int pa=0){
        int p=get();
        lc=rc=0,val[p]=v,siz[p]=all[p]=1,in[p]=1,fa[p]=pa;
        return p;
    }
    inline void getpos(int p,vector<int>&v){
        if(!p)return;
        getpos(lc,v);
        if(in[p])v.push_back(p);
        else del(p);
        getpos(rc,v);
    }
    inline int build(int l,int r,vector<int>v){
        if(l>=r)return 0;
        int mid=l+r>>1,p=v[mid];
        lc=build(l,mid,v),rc=build(mid+1,r,v),fa[lc]=fa[rc]=p;
        return pushup(p),p;
    }
    inline void rebuild(int&p){
        static vector<int>v;
        v.clear();
        int pa=fa[p];
        getpos(p,v);
        fa[(p=build(0,v.size(),v))]=pa;
    }
    inline int rank(int v){
        int p=rt,ret=1;
        while(p){
            if(v<=val[p])p=lc;
            else ret+=siz[lc]+in[p],p=rc;
        }
        return ret;
    }
    inline int kth(int k){
        int p=rt;
        while(p){
            if(siz[lc]+1==k&&in[p])return val[p];
            if(siz[lc]>=k)p=lc;
            else k-=siz[lc]+in[p],p=rc;
        }
    }
    inline int insert(int&p,int v){
        if(!p)return p=newnode(v),0;
        ++siz[p],++all[p];
        int ret;
        ret=insert(v<=val[p]?lc:rc,v),pushup(p);
        if(check(p))ret=p;
        return ret;
    }
    inline void insert(int v){
        int p=insert(rt,v);
        if(!p)return;
        if(p==rt)rebuild(rt);
        else{
            int f=fa[p];
            if(p==son[f][0])rebuild(son[f][0]);
            else rebuild(son[f][1]);
        }
    }
    inline void erase(int p,int k){
        --siz[p];
        if(in[p]&&k==siz[lc]+in[p]){in[p]=0;return;}
        if(k<=siz[lc])erase(lc,k);
        else erase(rc,k-siz[lc]-in[p]);
    }
    inline void erase(int v){
        erase(rt,rank(v));
        if(siz[rt]<alpha*all[rt])rebuild(rt);
    }
    inline int pre(int v){return kth(rank(v)-1);}
    inline int suf(int v){return kth(rank(v+1));}
}sgt;
int n;
int main(){
    n=read();
    while(n--){
        int op=read(),v=read();
        switch(op){
            case 1:sgt.insert(v);break;
            case 2:sgt.erase(v);break;
            case 3:printf("%d\n",sgt.rank(v));break;
            case 4:printf("%d\n",sgt.kth(v));break;
            case 5:printf("%d\n",sgt.pre(v));break;
            case 6:printf("%d\n",sgt.suf(v));break;
        }
    }
    return 0;
}