c++ FHQ Treap
前面我们对平衡树有了个大概的了解
关于 Treap
Treap=Binary Search Tree + Heap
二叉搜索树 + 二叉堆(一般是小根堆)
Treap 每一个节点有两个值
一个值是平衡树的值,一个值是随机的(用于堆来保持平衡)
二叉堆的性质使其保持平衡
关于 FHQ Treap
这个名字来源很简单: FHQ 大佬发明的 Treap
普通的 Treap 是通过旋转来平衡的
而 FHQ Treap 是通过合并、分裂来维护的
核心操作
约定
变量名 | 作用 |
---|---|
sz[] | 存储以某个节点为根的子树的节点数(包括它自己) |
l[] | 某个节点的左孩子 |
r[] | 某个节点的右孩子 |
fix[] | 维护平衡的随机值 |
val[] | 原本树上的值 |
cnt | 节点个数 |
root | 当前平衡树的根节点 |
基本操作
很简单,看一下就可以明白了
push_up
更新节点子树的节点数,注意包括节点本身
inline void push_up(int o){
sz[o]=sz[l[o]]+sz[r[o]]+1;
}
new_node
创建新节点,返回当前节点下标
别忘了初始化种子,不然随机数很多都一样
inline int new_node(int num){
cnt++;
sz[cnt]=1;
val[cnt]=num;
fix[cnt]=rand();
return cnt;
}
正式开始
这两个操作都是用递归实现的
常数有点大
不过应该还是很好理解的 QwQ
分裂 Split
void split(int now,int k,int &x,int &y){
if(!now) x=y=0;
else{
if(val[now]<=k) x=now,split(r[now],k,r[x],y);
else y=now,split(l[now],k,x,l[y]);
push_up(now);
}
}
void split(int now,int k,int &x,int &y){
if(!now) x=y=0;
else{
int tmp=size[l[now]]+1;
if(tmp<=k) x=now,split(r[now],k-tmp,r[x],y);
else y=now,split(l[now],k,x,l[y]);
push_up(now);
}
}
一个按 val 分裂,一个按 sz 分裂,思路基本相同。
作用:把以 now 为根的子树按照权值 k 分成 x 和 y 两颗子树
分完之后权值比 k 大的都在 y 子树中,其他的都在 x 子树中
思路(以按照权值分裂为例):
- 根节点为空,两个子树也为空,直接返回
- 根节点权值比 k 小,根节点和其左子树都给 x ,把根节点的右子树继续分成 r[x] 和 y 两颗子树
- 否则,根节点和其右子树都给 y ,把根节点的左子树继续分成 x 和 l[y] 两颗子树
- 分裂完毕,更新根节点的 sz
合并 Merge
int merge(int x,int y){
if(!x||!y) return x+y;
if(fix[x]<fix[y]) return r[x]=merge(r[x],y),push_up(x),x;
return l[y]=merge(x,l[y]),push_up(y),y;
}
作用:把 x 和 y 两颗子树合并成一颗树,并返回根节点
思路:
- 有一颗子树为空,直接返回 x + y (如果存在,不为空的那颗子树)
- fix[x]<fix[y] ,为满足小根堆的性质,先将 r[x] 和 y 合并,然后更新 x 的 sz ,最后将 x 作为根节点
- 否则,先将 l[y] 和 x 合并,然后更新 y 的 sz ,最后将 y 作为根节点
其他操作
有了这两个核心操作已经可以干很多事了
注意:分裂的子树 x 、 y 和 z 自行定义
Insert 插入节点
作用:添加值为 val 的节点
思路:把树按照插入的值分裂成 x 和 y ,再把插入的值看成一棵树与 y 合并,再将 y 和 x 合并
inline void ins(int val){
split(root,val,x,y);
root=merge(x,merge(new_node(val),y));
return;
}
还有另一种思路:直接将这颗子树与根节点合并,简单粗暴
void ins(int val){
root=merge(root,new_node(val));
}
Delete 删除节点
作用:删除值为 val 的节点
思路:找到以要删除的节点的值所在的子树,把其左子树和右子树合并,再把所有的子树合并,这个节点就删除了。
inline void del(int val){
split(root,val,x,z);split(x,val-1,x,y);
y=merge(l[y],r[y]);
root=merge(x,merge(y,z));
}
Rank 查询排名
作用:查询值为 val 再树中的排名。
思路:返回 val 左子树的 sz+1 ,记得合并
inline int rnk(int val){
split(root,val-1,x,y);
int ans=sz[x]+1;
root=merge(x,y);
return ans;
}
Kth 第 K 大
作用:查询以 o 为根节点的子树中排名为 rank 的值
思路:
- rank 等于当前节点左子树的 sz+1 ,直接返回 val[o]
- rank 小于左子树的 sz ,向左搜索, rank 不变
- 否则,向右搜索, rank 减去左子树的 sz+1
inline int kth(int o,int rank){
if(rank<=sz[l[o]]) return kth(l[o],rank);
if(rank==sz[l[o]]+1) return val[o];
return kth(r[o],rank-sz[l[o]]-1);
}
Precursor 前驱
前驱定义:小于 x 的最大值,不存在根据题目要求
作用:查询值为 v 的前驱
思路:把树按照 v-1 分裂,如果那棵树不为空,就查询排名为 sz 的(最大),否则按照要求
注意:按照 v-1 分裂使得一棵子树全部都是小于 v 的
inline int pre(int v){
split(root,v-1,x,y);
int ans=sz[x]?kth(x,sz[x]):-2147483647;
root=merge(x,y);
return ans;
}
Successor 后继
后继定义:大于 x 的最小值,不存在根据题目要求
作用:查询值为 v 的后继
思路:把树按照 v 分裂,如果那棵树不为空,就查询排名为 1 的(最小),否则按照要求
注意:按照 v 分裂使得一棵子树全部都是大于 v 的
inline int suc(int v){
split(root,v,x,y);
int ans=sz[y]?kth(y,1):2147483647;
root=merge(x,y);
return ans;
}
高级操作
垃圾回收
由于删除节点后那个下标就空出来,以后就都没用过了,所以可以用一个数组存起来,优化空间
假设垃圾桶是 bin[] ,尾指针是 top
这时我们的 Delete 应该改动一下,把没用的下标加入队列中
inline void del(int val){
split(root,val,x,z);split(x,val-1,x,y);
bin[++top]=y,y=merge(l[y],r[y]);
root=merge(x,merge(y,z));
}
增加新节点的函数也有所改动
inline int new_node(int num){
int cur=top?bin[top--]:++cnt;
l[cur]=r[cur]=0;
sz[cur]=1;
val[cur]=num;
fix[cur]=rand();
return cur;
}
注意:一定要把一个节点的左右儿子给清空,因为有可能之前用过
例题
#include<bits/stdc++.h>
#define maxn 500001
using namespace std;
int sz[maxn],l[maxn],r[maxn],fix[maxn],val[maxn];
int T,cnt,n,m,x,y,z,p,a,root,bin[maxn],top;
inline int read(){
int x=0,f=1;char c=getchar();
for(;c<'0'||c>'9';c=getchar())
if(c=='-') f=-1;
for(;c>'/'&&c<':';c=getchar())
x=(x<<1)+(x<<3)+(c^48);
return x*f;
}
inline void write(int x){
if(x<0){x=-x;putchar('-');}
if(x>9) write(x/10);
putchar(x%10+'0');
}
inline void wl(int x){write(x);putchar('\n');}
inline void push_up(int x)
{
sz[x]=1+sz[l[x]]+sz[r[x]];
}
inline int new_node(int x){
int cur=top?bin[top--]:++cnt;
l[cur]=r[cur]=0;
sz[cur]=1;
val[cur]=x;
fix[cur]=rand();
return cur;
}
inline void split(int now,int k,int &x,int &y){
if(!now) x=y=0;
else{
if(val[now]<=k) x=now,split(r[now],k,r[x],y);
else y=now,split(l[now],k,x,l[y]);
push_up(now);
}
}
inline int merge(int x,int y){
if(!x||!y) return x+y;
if(fix[x]<fix[y]) return r[x]=merge(r[x],y),push_up(x),x;
return l[y]=merge(x,l[y]),push_up(y),y;
}
int kth(int now,int rank){
if(sz[l[now]]+1==rank) return val[now];
if(rank<=sz[l[now]]) return kth(l[now],rank);
return kth(r[now],rank-sz[l[now]]-1);
}
int main(){
srand((unsigned)time(NULL));
T=read();
while(T--){
p=read();a=read();
if(p==1){
split(root,a,x,y);
root=merge(merge(x,new_node(a)),y);
}
else if(p==2){
split(root,a,x,z);split(x,a-1,x,y);
bin[++top]=y;y=merge(l[y],r[y]);
root=merge(x,merge(y,z));
}
else if(p==3){
split(root,a-1,x,y);
wl(sz[x]+1);
root=merge(x,y);
}
else if(p==4) wl(kth(root,a));
else if(p==5){
split(root,a-1,x,y);
wl(kth(x,sz[x]));
root=merge(x,y);
}
else{
split(root,a,x,y);
wl(kth(y,1));
root=merge(x,y);
}
}
return 0;
}
可持久化
可持久化就是回到某一时刻进行操作,需要一个 rt[] 代替 root 存储每一时刻的根节点
我们只需将分裂劈出来的链上的每个点都 copy 一个新节点,合并的时候合并的也是新节点
这样合并时就不用新增节点了,因为合并之前肯定要分裂,而分裂已经新建好了,这样可以减少很多时间和空间
Copy 函数实现:
inline void copy(int cur,int old){
sz[cur]=sz[old];
val[cur]=val[old];
l[cur]=l[old];
r[cur]=r[old];
fix[cur]=fix[old];
return;
}
更改后的 Split :
void split(int now,int k,int &x,int &y){
if(!now) x=y=0;
else{
if(val[now]<=k) {
x=++cnt;
copy(x,now);
split(r[x],k,r[x],y);
push_up(x);
}
else{
y=++cnt;
copy(y,now);
split(l[y],k,x,l[y]);
push_up(y);
}
}
}
注意:可持久化的题输入会给你版本号 v ,记得 rt[i]=rt[v] ,并且所有操作在 rt[i] 上执行
例题
#include<bits/stdc++.h>
#define N 500005*50
using namespace std;
inline int read(){
int x=0,f=1;char c=getchar();
for(;c<'0'||c>'9';c=getchar())
if(c=='-') f=-1;
for(;c>'/'&&c<':';c=getchar())
x=(x<<1)+(x<<3)+(c^48);
return x*f;
}
inline void write(int x){
if(x<0){x=-x;putchar('-');}
if(x>9) write(x/10);
putchar(x%10+'0');
}
inline void wl(int x){write(x);putchar('\n');}
int n,val[N],fix[N],l[N],r[N],sz[N],cnt,rt[500005];
inline int newnode(int x){
sz[++cnt]=1;
val[cnt]=x;
fix[cnt]=rand();
return cnt;
}
inline void copy(int cur,int old){
sz[cur]=sz[old];
val[cur]=val[old];
l[cur]=l[old];
r[cur]=r[old];
fix[cur]=fix[old];
return;
}
inline void push_up(int x){
sz[x]=sz[l[x]]+sz[r[x]]+1;
}
void split(int now,int k,int &x,int &y){
if(!now) x=y=0;
else{
if(val[now]<=k) {
x=++cnt;
copy(x,now);
split(r[x],k,r[x],y);
push_up(x);
}
else{
y=++cnt;
copy(y,now);
split(l[y],k,x,l[y]);
push_up(y);
}
}
}
int merge(int x,int y){
if(x==0||y==0) return x+y;
if(fix[x]<fix[y]){
r[x]=merge(r[x],y);
push_up(x);
return x;
}
else{
l[y]=merge(x,l[y]);
push_up(y);
return y;
}
}
int kth(int now,int rank){
if(sz[l[now]]+1==rank) return val[now];
if(rank<=sz[l[now]]) return kth(l[now],rank);
return kth(r[now],rank-sz[l[now]]-1);
}
int main(){
srand((unsigned)time(NULL));
n=read();
for(register int i=1;i<=n;i++){
int v,opt,a,b,x,y,z;
v=read(),opt=read(),a=read();
rt[i]=rt[v];
if(opt==1){
split(rt[i],a,x,y);
rt[i]=merge(merge(x,newnode(a)),y);
}
else if(opt==2){
split(rt[i],a,x,z);
split(x,a-1,x,y);
y=merge(l[y],r[y]);
rt[i]=merge(merge(x,y),z);
}
else if(opt==3){
split(rt[i],a-1,x,y);
wl(sz[x]+1);
rt[i]=merge(x,y);
}
else if(opt==4) wl(kth(rt[i],a));
else if(opt==5){
split(rt[i],a-1,x,y);
if(!sz[x]) puts("-2147483647");
else wl(kth(x,sz[x]));
rt[i]=merge(x,y);
}
else if(opt==6){
split(rt[i],a,x,y);
if(!sz[y]) puts("2147483647");
else wl(kth(y,1));
rt[i]=merge(x,y);
}
}
}
区间翻转
例题
解析
首先要知道:这颗平衡树的中序遍历为原数组
并且运用了线段树下传懒标记的思想,用数组 tag[] 记录,表示当前子树是否要翻转
意思是:这个地方做个记号,以后到这了顺便传下去,这样减少了很多次重复的翻转
传标记 down 实现:
inline void down(int x){
if(tag[x]){
swap(l[x],r[x]);
if(l[x]) tag[l[x]]^=1;
if(r[x]) tag[r[x]]^=1;
tag[x]=0;
}
}
传标记中的 swap 相当于普通翻转中的交换,根节点即为中间点
要注意,这里需要按照 sz 分裂
只需把树分成了三个部分,将中间那个子树打上标记,再把所有的合并,就实现了区间翻转了
void rev(int l,int r){
split(root,l-1,x,y);
split(y,r-l+1,y,z);
tag[y]^=1;
y=merge(y,z);
root=merge(x,y);
}
更改后的分裂和合并
要先传标记
int merge(int x,int y){
if(!x||!y) return x+y;
if(fix[x]<fix[y]){
down(x);
r[x]=merge(r[x],y);
push_up(x);
return x;
}
else{
down(y);
l[y]=merge(x,l[y]);
push_up(y);
return y;
}
}
void split(int now,int k,int &x,int &y){
if(!now) x=y=0;
else{
down(now);
int tmp=size[l[now]]+1;
if(tmp<=k) x=now,split(r[now],k-tmp,r[x],y);
else y=now,split(l[now],k,x,l[y]);
push_up(now);
}
}
还需要一个输出,输出树的中序遍历
这里先传标记解决了标记没传完的问题
void print(int now){
if(!now) return;
down(now);
print(l[now]);
printf("%d ",val[now]);
print(r[now]);
}
代码
#include<bits/stdc++.h>
#define maxn 4000001
using namespace std;
int size[maxn],l[maxn],r[maxn],fix[maxn];
int val[maxn],tag[maxn];
int T,cnt,n,m,root,lt,rt;
inline int read(){
int x=0,f=1;char c=getchar();
for(;c<'0'||c>'9';c=getchar())
if(c=='-') f=-1;
for(;c>'/'&&c<':';c=getchar())
x=(x<<1)+(x<<3)+(c^48);
return x*f;
}
inline void write(int x){
if(x<0){x=-x;putchar('-');}
if(x>9) write(x/10);
putchar(x%10+'0');
}
inline void push_up(int x)
{
size[x]=1+size[l[x]]+size[r[x]];
}
inline void down(int x){
if(tag[x]){
swap(l[x],r[x]);
if(l[x]) tag[l[x]]^=1;
if(r[x]) tag[r[x]]^=1;
tag[x]=0;
}
}
inline int new_node(int x){
cnt++;
size[cnt]=1;
val[cnt]=x;
fix[cnt]=rand();
tag[cnt]=0;
return cnt;
}
int merge(int x,int y){
if(!x||!y) return x+y;
if(fix[x]<fix[y]){
down(x);
r[x]=merge(r[x],y);
push_up(x);
return x;
}
else{
down(y);
l[y]=merge(x,l[y]);
push_up(y);
return y;
}
}
void split(int now,int k,int &x,int &y){
if(!now) x=y=0;
else{
down(now);
int tmp=size[l[now]]+1;
if(tmp<=k) x=now,split(r[now],k-tmp,r[x],y);
else y=now,split(l[now],k,x,l[y]);
push_up(now);
}
}
void ins(int val){
root=merge(root,new_node(val));
}
void print(int now){
if(!now) return;
if(tag[now]) down(now);
print(l[now]);
write(val[now]),putchar(32);
print(r[now]);
}
void rev(int l,int r){
int x=0,y=0,z=0;
split(root,l-1,x,y);
split(y,r-l+1,y,z);
tag[y]^=1;
y=merge(y,z);
root=merge(x,y);
}
int main(){
srand(time(0));
n=read(),m=read();
for(register int i=1;i<=n;i++) ins(i);
while(m--){
lt=read(),rt=read();
rev(lt,rt);
}
print(root);
}
The End
本文作者:小蒟蒻laf
本文链接:https://www.cnblogs.com/KonjakLAF/p/12759259.html
版权声明:本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步