平衡树合集(Treap,Splay,替罪羊,FHQ Treap)

今天翻了翻其他大佬的博客,发现自己有些。。。颓废。。。

有必要洗心革面,好好学习


序:正常的BST有可能退化,成为链,大大降低效率,所以有很多方法来保持左右size的平衡,本文将简单介绍Treap,Splay,替罪羊,FHQ Treap;

另:代码都是普通平衡树

1.Treap

树堆,在数据结构中也称Treap,是指有一个随机附加域满足堆的性质的二叉搜索树,其结构相当于以随机数据插入的二叉搜索树。其基本操作的期望时间复杂度为O(logn)。相对于其他的平衡二叉搜索树,Treap的特点是实现简单,且能基本实现随机平衡的结构。——百度百科

好的treap=tree+heap(为何不叫hee??)

首先易知堆是棵二叉树,BST也是棵二叉树,

又易知:当堆的中的数据是随机插入(即不是有序数据&&有序插入),堆的的高度是趋于log级别的

于是我们让BST中的节点满足堆性质,让BST中的每一个节点带上一个随机权值dat,作为他在这个满足堆性质的BST中的优先级;

然后为了让BST中的节点满足堆性质,我们要rotate(旋)他

易知以下两种是等价的

仍然满足BST的性质,但是改变了父子关系。

这就是如何在BST中维护堆性质:旋,改变父子关系,直到满足堆性质

PS:此处的旋好像叫单旋,只会改变父子关系,而Splay有一种操作较双旋(见下)

rotate(旋)在一类BST中我认为是最重要的操作

上代码:

ch[x][0/1]左右儿子,vl[x]权值,dat[x]在堆中的优先级,sz[x]子树大小,cnt[x]是vl[x]出现的次数

#include<cstdio>
#include<iostream>
#include<cstdlib>
#define ls ch[x][0]
#define rs ch[x][1]
#define R register int
using namespace std;
const int N=100010,Inf=0x3f3f3f3f;
inline int g() {
    R ret=0,fix=1; register char ch; while(!isdigit(ch=getchar())) fix=ch==‘-‘?-1:fix;
    do ret=ret*10+(ch^48); while(isdigit(ch=getchar())); return ret*fix;
}
int n,tot,rt;
int sz[N],ch[N][2],vl[N],dat[N],cnt[N];
inline void upd(int x) {sz[x]=sz[ls]+sz[rs]+cnt[x];}
inline int cre(int v) {R x=++tot; cnt[x]=1,vl[x]=v,dat[x]=rand(),upd(x); return tot;}
inline void rot(int& x,int d) { R y=ch[x][d];
    ch[x][d]=ch[y][d^1]; ch[y][d^1]=x; upd(x),upd(y); x=y;
}
inline void ins(int& x,int v) {
    if(!x) {x=cre(v); return ;}
    if(vl[x]==v) {++cnt[x]; upd(x); return ;} R d=vl[x]<v;
    ins(ch[x][d],v); upd(x); if(dat[ch[x][d]]<dat[x]) rot(x,d);
}
inline void del(int& x,int v) {
    if(!x) return ; if(vl[x]==v) {
        if(cnt[x]>1) --cnt[x]; else {
            if(!ls) x=rs; else if(!rs) x=ls;
            else {R d=dat[ls]>dat[rs]; rot(x,d); del(ch[x][d^1],v);}//看谁大就把谁旋上来,把根旋下去
        }
    } else del(ch[x][vl[x]<v],v); upd(x);
}
inline void build() {srand(100023323); rt=cre(-Inf); ins(rt,Inf);}
inline int getpre(int x,int v) {
    if(!x) return -Inf; if(vl[x]<v) return max(getpre(rs,v),vl[x]);//右边可能没有
    else return getpre(ls,v);
}
inline int getnxt(int x,int v) {
    if(!x) return Inf; if(vl[x]>v) return min(getnxt(ls,v),vl[x]);//同上
    else return getnxt(rs,v);
}
inline int getrk(int x,int v) {
    if(!x) return 0;
    if(vl[x]==v) return sz[ls]+1;
    else if(vl[x]>v) return getrk(ls,v);
    else return sz[ls]+cnt[x]+getrk(rs,v);
}
inline int getvl(int x,int rk) {
    if(!x||!rk) return 0;
    if(rk<=sz[ls]) return getvl(ls,rk);
    else if(rk<=sz[ls]+cnt[x]) return x;
    return getvl(rs,rk-sz[ls]-cnt[x]);
}
signed main() { //freopen("in.in","r",stdin);freopen("out.out","w",stdout);
    n=g(); for(R i=1;i<=n;++i) {
        R k=g(),x=g();
        if(k==1) ins(rt,x); else if(k==2) del(rt,x);
        else if(k==3) printf("%d\n",getrk(rt,x));
        else if(k==4) printf("%d\n",vl[getvl(rt,x)]);
        else if(k==5) printf("%d\n",getpre(rt,x));
        else printf("%d\n",getnxt(rt,x));
    } //while(1);
} 

2.Splay

伸展树(Splay)是一种平衡二叉树,即优化后的二叉查找树。伸展树可以自我调整,这就要依靠伸展操作Splay(x,S),使得提升效率。——洛谷日报

Splay,伸展树。。。维持左右子树平衡用到了另一种旋:双旋

设fa[x]=y,fa[y]=g

双旋,同时改变x,y与y,g之间的关系,它会使g变成x的孙子,y变为x的孩子,g变为y的孩子

分两种情况:

第一种如下

此时要先旋fa,再旋son(纯手绘不喜勿喷qwq);

第二种如下(不在一条链)

那么我们旋两次son

然后Splay的思路是:不管如何操作,将操作的点通过两种旋法,旋至根节点

至于为什么这么旋请找tarjan。。。至于时间复杂度请找tarjan

#include<cstdio>
#include<iostream>
#define R register int
#define ls (ch[x][0])
#define rs (ch[x][1])
const int N=100005,Inf=0x3f3f3f3f;
using namespace std;
inline int g() {
    R ret=0,fix=1; register char ch; while(!isdigit(ch=getchar())) fix=ch==‘-‘?-1:fix;
    do ret=ret*10+(ch^48); while(isdigit(ch=getchar())); return ret*fix;
}
int n,tot;
int fa[N],ch[N][2],sz[N],vl[N],cnt[N];
inline int cre(int v) {vl[++tot]=v,sz[tot]=cnt[tot]=1; return tot;}
inline void upd(int x) {sz[x]=sz[ls]+cnt[x]+sz[rs];}
inline void rot(int x) {
    R y=fa[x],d=ch[y][1]==x;
    if(fa[y]) ch[fa[y]][ch[fa[y]][1]==y]=x;
    fa[x]=fa[y]; fa[ch[y][d]=ch[x][d^1]]=y;
    fa[ch[x][d^1]=y]=x; upd(y);
}
int rt;
inline void print(int x) {
    if(!x) return ; print(ls);
    printf("%d\n",vl[x]); print(rs);
}
inline void Splay(int x,int f) {
    while(fa[x]!=f) {
        R y=fa[x]; if(fa[y]!=f)
            rot((ch[y][1]==x)==(ch[fa[y]][1]==y)?y:x); //在不在一条链上
        rot(x);
    } upd(x); if(!f) rt=x;
}
inline void ins(int v) {
    R x=rt; while(1) {
        if(vl[x]==v) {++cnt[x]; break;}
        if(!ch[x][vl[x]<v]) {
            fa[ch[x][vl[x]<v]=cre(v)]=x;
            x=tot; break;
        } x=ch[x][vl[x]<v];
    } Splay(x,0);
}
inline void build() {rt=cre(Inf),ins(-Inf);}
inline int getrk(int v) {
    R x=rt,ret=0; while(1) {
        if(vl[x]==v) {ret+=sz[ls]+1; Splay(x,0); return ret;}
        if(vl[x]<v) ret+=sz[ls]+cnt[x];
        if(!ch[x][vl[x]<v]) {++ret; Splay(x,0); return ret;}
        x=ch[x][vl[x]<v];
    }
}
inline int getpos(int x,int k) {
    if(!x) return 0;
    if(k<=sz[ls]) return getpos(ls,k);
    if(k<=sz[ls]+cnt[x]) return x;
    return getpos(rs,k-sz[ls]-cnt[x]);
}
inline int getvl(int rk) {R x=getpos(rt,rk); Splay(x,0); return vl[x];}
inline int getmx(int x,int y) {if(!x||!y) return x|y; return vl[x]>vl[y]?x:y;}
inline int ppos(int x,int v) {
    if(!x) return 0; if(vl[x]<v) return getmx(x,ppos(rs,v));
    return ppos(ls,v);
}
inline int getpre(int v) {R x=ppos(rt,v); Splay(x,0); return vl[x];}
inline int getmn(int x,int y) {if(!x||!y) return x|y; return vl[x]<vl[y]?x:y;}
inline int npos(int x,int v) {
    if(!x) return 0; if(v<vl[x]) return getmn(x,npos(ls,v));
    return npos(rs,v);
}
inline int getnxt(int v) {R x=npos(rt,v); Splay(x,0); return vl[x];}
inline void del(int v) {
    Splay(ppos(rt,v),0),Splay(npos(rt,v),rt);
    R& x=ch[ch[rt][1]][0]; if(!(--cnt[x])) x=0; else Splay(x,0);
}
signed main() {
    //freopen("in.in","r",stdin);
    R n=g(); build(); while(n--) {
        R k=g(),x=g();
        if(k==1) ins(x);
        else if(k==2) del(x);
        else if(k==3) printf("%d\n",getrk(x)-1);
        else if(k==4) printf("%d\n",getvl(x+1));
        else if(k==5) printf("%d\n",getpre(x));
        else printf("%d\n",getnxt(x));
    }
    //system("pause"); while(1);
}

3.替罪羊树

为何叫替罪羊。。。据说拍扁他是他儿子的锅。。。

替罪羊维护左右孩子平衡思路:当max(size(x.ls),size(x.rs))>size(x)*alpha(一个常量,一般0.7-0.8,看个人的喜好。。。),就暴力重构以x为根的子树。

具体地,就是把树拍扁,扔到数组中sort一遍,然后选mid,递归左子树和右子树;

然而替罪羊的删除是懒惰删除。。就是打一个tag。、所以用到儿子时要向下传递。。暴力重构时把删除的节点扔到内存池里去

所以, 特别地,当整个树实际存在的的节点数<整个树的节点数*B(另一个常量,合法范围是0.0-1.0,至于取多少看个人)

变量:sum总节点数=实际存在的节点数+删除的节点数; sz实际存在的节点数;del删除标记;mem存储删除的或没有使用的点;tmp存储拍扁重构的的点

#include<cstdio>
#include<iostream>
#define R register int
using namespace std;
const double A=0.72,RB=0.53;
const int N=100010;
inline int g() {
    R ret=0,fix=1; register char ch; while(!isdigit(ch=getchar())) fix=ch==‘-‘?-1:fix;
    do ret=ret*10+(ch^48); while(isdigit(ch=getchar())); return ret*fix;
}
struct node{
    int ls,rs,vl,sz,sum,del;
    #define ls(x) t[x].ls
    #define rs(x) t[x].rs
    #define vl(x) t[x].vl
    #define sz(x) t[x].sz
    #define sum(x) t[x].sum
    #define del(x) t[x].del
}t[N];
int n,rt;
int mem[N],cm,tmp[N],ct;
inline bool ck(int x) {return (double)sz(x)*A<=(double)max(sz(ls(x)),sz(rs(x)));}
inline void dfs(int x) {
    if(!x) return ; dfs(ls(x));
    if(!del(x)) tmp[++ct]=x;
    else mem[++cm]=x;
    dfs(rs(x));
}
inline void build(int& x,int l,int r) {
    R md=l+r>>1; x=tmp[md]; if(l==r) {
        ls(x)=rs(x)=del(x)=0; sz(x)=sum(x)=1; return ;
    } if(l<md) build(ls(x),l,md-1); else ls(x)=0;
    build(rs(x),md+1,r);
    sz(x)=sz(ls(x))+sz(rs(x))+1, sum(x)=sum(ls(x))+sum(rs(x))+1;
}
inline void rebuild(int& x) {
    ct=0; dfs(x); if(ct) build(x,1,ct); else x=0;
}
inline void ins(int& x,int vl) {
    if(!x) {
        x=mem[cm--]; vl(x)=vl,ls(x)=rs(x)=del(x)=0; sz(x)=sum(x)=1; return ;
    } ++sz(x),++sum(x);
    if(vl(x)>=vl) ins(ls(x),vl);
    else ins(rs(x),vl); if(ck(x)) rebuild(x);
}
inline int getrk(int vl) {
    R x=rt; R ret=1; while(x) {
        if(vl(x)>=vl) x=ls(x);
        else {ret+=sz(ls(x))+(del(x)==0); x=rs(x);}
    } return ret;
}
inline int getvl(int rk) {
    R x=rt; while(x) { //cout<<x<<" "<<vl(x)<<endl;
        if(del(x)==0&&sz(ls(x))+1==rk) return vl(x);
        else {
            if(sz(ls(x))+1>rk) x=ls(x);
            else {
                rk-=sz(ls(x))+(del(x)==0);
                x=rs(x);
            }
        }
    }
}
inline void delrk(int& x,int rk) {
    if(del(x)==0&&sz(ls(x))+1==rk) {del(x)=1; --sz(x); return ;}
    --sz(x); if(sz(ls(x))+(del(x)==0)>=rk) delrk(ls(x),rk);
    else delrk(rs(x),rk-sz(ls(x))-(del(x)==0));
}
inline void delvl(int vl) { R x=getrk(vl); //cerr<<x<<endl;
    delrk(rt,x);
    if(sum(rt)*RB>=sz(rt)) rebuild(rt);
}
signed main() { //freopen("in.in","r",stdin); freopen("out.out","w",stdout);
    n=g(); for(R i=100000;i>=1;--i) mem[++cm]=i;
    while(n--) {
        R k=g(),x=g();
        if(k==1) ins(rt,x); else if(k==2) delvl(x);
        else if(k==3) printf("%d\n",getrk(x));
        else if(k==4) printf("%d\n",getvl(x));
        else if(k==5) printf("%d\n",getvl(getrk(x)-1));
        else if(k==6) printf("%d\n",getvl(getrk(x+1)));
    } //while(1);
}

4.FHQ Treap

首先%%%fhq%%%

其次就是这个Treap不用旋,很好理解。。。

两个操作:split和merge

1.split(int o,int v,int& x,int& y) 把以o为根的树分<=v和>v的两部分

也可按照rank去分成两部分

2.merge(int x,int y) 合并以x和y为根的子树,返回新的根的值

短小而精悍。。。

#include<cstdio>
#include<iostream>
#include<cstdlib>
#define R register int
#define ls(i) ch[i][0]
#define rs(i) ch[i][1]
using namespace std;
const int N=500010;
inline int g() {
    R ret=0,fix=1; register char ch; while(!isdigit(ch=getchar())) fix=ch==‘-‘?-1:fix;
    do ret=ret*10+(ch^48); while(isdigit(ch=getchar())); return ret*fix;
}
int tot;
int ch[N][2],sz[N],vl[N],dat[N];
inline void upd(int x) {sz[x]=sz[ls(x)]+sz[rs(x)]+1;}
inline int cre(int v) {R x=++tot; sz[x]=1,vl[x]=v,dat[x]=rand();return x;}
inline int merge(int x,int y) {
    if(!x||!y) return x+y;
    if(dat[x]<dat[y]) {rs(x)=merge(rs(x),y); upd(x); return x;}
    else {ls(y)=merge(x,ls(y)); upd(y); return y;}
}
inline void split(int o,int v,int& x,int& y) {
    if(!o) {x=y=0; return ;}
    if(vl[o]<=v) x=o,split(rs(o),v,rs(o),y);
    else y=o,split(ls(o),v,x,ls(o)); upd(o);
}
inline int getvl(int x,int rk) {
    while(1) { if(rk<=sz[ls(x)]) x=ls(x);
        else if(rk==sz[ls(x)]+1) return x;
        else rk-=sz[ls(x)]+1,x=rs(x);
    }
}
signed main() { srand(100023323u); R n,x,y,z,rt=0; //freopen("1.in","r",stdin);freopen("out.out","w",stdout);
    n=g(); while(n--) {  //cerr<<n<<" "<<rt<<" "<<endl;
        R k=g(),a=g(); if(k==1) split(rt,a,x,y),rt=merge(merge(x,cre(a)),y);
        else if(k==2) {split(rt,a,x,z),split(x,a-1,x,y); y=merge(ls(y),rs(y)),rt=merge(merge(x,y),z);}
        else if(k==3) split(rt,a-1,x,y),printf("%d\n",sz[x]+1),rt=merge(x,y);
        else if(k==4) printf("%d\n",vl[getvl(rt,a)]);
        else if(k==5) split(rt,a-1,x,y),printf("%d\n",vl[getvl(x,sz[x])]),rt=merge(x,y);
        else if(k==6) split(rt,a,x,y),printf("%d\n",vl[getvl(y,1)]),rt=merge(x,y);
    } while(1);
}


2019.05.05&&2019.05.06

原文地址:https://www.cnblogs.com/Jackpei/p/10818586.html

时间: 2024-10-02 18:25:47

平衡树合集(Treap,Splay,替罪羊,FHQ Treap)的相关文章

三大平衡树(Treap + Splay + SBT)总结+模板

Treap树 核心是 利用随机数的二叉排序树的各种操作复杂度平均为O(lgn) Treap模板: #include <cstdio> #include <cstring> #include <ctime> #include <iostream> #include <algorithm> #include <cstdlib> #include <cmath> #include <utility> #include

平衡树讲解(旋转treap,非旋转treap,splay)

在刷了许多道平衡树的题之后,对平衡树有了较为深入的理解,在这里和大家分享一下,希望对大家学习平衡树能有帮助. 平衡树有好多种,比如treap,splay,红黑树,STL中的set.在这里只介绍几种常用的:treap和splay(其中treap包括旋转treap和非旋转treap). 一.treap treap这个词是由tree和heap组合而成,意思是树上的的堆(其实就是字面意思啦qwq).treap可以说是由二叉搜索树(BST)进化而来,二叉搜索树每个点满足它左子树中所有点权值都比它小,它右子

【bzoj1251】序列终结者——fhq treap

Description 给定一个长度为N的序列,每个序列的元素是一个整数.要支持以下三种操作: 1. 将[L,R]这个区间内的所有数加上V. 2. 将[L,R]这个区间翻转,比如1 2 3 4变成4 3 2 1. 3. 求[L,R]这个区间中的最大值. 最开始所有元素都是0. Input 第一行两个整数N,M.M为操作个数. 以下M行,每行最多四个整数,依次为K,L,R,V.K表示是第几种操作,如果不是第1种操作则K后面只有两个数. Output 对于每个第3种操作,给出正确的回答. Sampl

FHQ Treap小结(神级数据结构!)

首先说一下, 这个东西可以搞一切bst,treap,splay所能搞的东西 pre 今天心血来潮, 想搞一搞平衡树, 先百度了一下平衡树,发现正宗的平衡树写法应该是在二叉查找树的基础上加什么左左左右右左右右的旋转之类的, 思路比较好理解,但是 代码量........ 一看就头大,, 然后,在洛谷翻题解的时候无意间看到了远航之曲发的一篇非常短小精悍的题解, 于是就学了一下 FHQ Treap 这个东西的学名应该是叫做fhq treap,应该是treap的强化版. 整个数据结构中只有两个操作: 1.

fhq treap

fhq-treap 小结 粗浅地学习了这个神奇的数据结构,下面瞎写一些感受 首先fhq treap是一个基于分裂与合并的平衡树,那么怎么分裂,怎么合并呢 我们分两种情况考虑 一.权值平衡树(我自己取的名字) 所谓权值平衡树,就是任何操作都只与权值有关的平衡树 比如最基础的分裂,合并操作 分裂就是把平衡树按照权值\(k\)分成两半,一边所有点的权值\(\leq k\),另一边权值\(\gt k\) 怎么分裂呢 首先根据\(treap\)的定义,所有点的权值是一颗二叉搜索树(BST),就是左边比他小

浅谈fhq treap

一.简介 fhq treap 与一般的treap主要有3点不同 1.不用旋转 2.以merge和split为核心操作,通过它们的组合实现平衡树的所有操作 3.可以可持久化 二.核心操作 代码中val表示节点权值,pri表示节点的优先级,维护小根堆 1.split 将1个treap分裂为两个treap 分裂主要有两种:以权值k作为分界点.以位置k作为分界点 ①以权值k作为分界点 设原来的treap根节点为root,分裂后的<=k的treap A 的根节点为x,>k的treap B 的根节点为y

【POJ2761】【fhq treap】A Simple Problem with Integers

Description You have N integers, A1, A2, ... , AN. You need to deal with two kinds of operations. One type of operation is to add some given number to each number in a given interval. The other is to ask for the sum of numbers in a given interval. In

P2710 数列[fhq treap]

调了一辈子的fhq treap- 如果不会最大子段和 如果不会fhq treap 7个操作- 其中三个查询 单点查询其实可以和区间查询写成一个( fhq treap 的修改操作大概就是 \(split\) 完了然后把修改区间的根 打上标记 等着下传就完事了- 那这题没了-我给个好一点的小数据-反正我照着这个调了挺久的- .in 50 10 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 3

智障操作合集

再不写这个我真的会因为智商过低而死 7.28 https://www.cnblogs.com/chloris/p/11260955.html插头dp智障操作合集 7.30 P4093 序列 CDQ分治优化DP  排序时b+l打成了b+1导致各种TLE 方案数的+1写在了ask查找的括号里面,导致ask(b[rr].pos)+1变成了ask(b[rr].pos+1) P4141 消失之物 题目要求输出末尾数字[%10],我:全部输出 NOIP模拟测试10 T2 模板 写splay的时候,rotat