无旋Treap的可持久化

无旋Treap的可持久化

解析

其实 F H Q T r e a p FHQ Treap FHQTreap的可持久化非常好理解,只需要的每次操作的 r t rt rt用数组记录下来,然后操作时,节点新建即可

模板题 P3835

注意操作细节
注意数组大小
注意 r a n d ( ) rand() rand()的值域

代码

#include<bits/stdc++.h>
#define int long long
#define M 30000009
using namespace std;
const int mod=998244353;
int read(){
	int f=1,re=0;
	char ch;
	for(ch=getchar();!isdigit(ch)&&ch!='-';ch=getchar());
	if(ch=='-'){f=-1,ch=getchar();}
	for(;isdigit(ch);ch=getchar()) re=(re<<3)+(re<<1)+ch-'0';
	return re*f; 
}
int val[M],pos[M],siz[M],cnt,root[M],n,son[M][2];
void pushup(int k){siz[k]=siz[son[k][0]]+siz[son[k][1]]+1;}
void copy(int &x,int y){//新建节点
	x=++cnt;
	son[x][1]=son[y][1],son[x][0]=son[y][0];
	siz[x]=siz[y],val[x]=val[y],pos[x]=pos[y];
}
int build(int x){
	val[++cnt]=x,siz[cnt]=1,pos[cnt]=rand();
	return cnt;
}
void split(int rt,int &a,int &b,int v){
	if(!rt){a=b=0;return;} 
	if(val[rt]<=v) copy(a,rt),split(son[a][1],son[a][1],b,v),pushup(a);
	else copy(b,rt),split(son[b][0],a,son[b][0],v),pushup(b);
}
int merge(int a,int b){
	int rt;
	if(!a||!b) return a+b;
	if(pos[a]<pos[b]) copy(rt,a),son[rt][1]=merge(son[rt][1],b);
	else copy(rt,b),son[rt][0]=merge(a,son[rt][0]);
	pushup(rt);return rt;	
}
int kth(int rt,int v){
	if(siz[son[rt][0]]>=v) return kth(son[rt][0],v);
	if(siz[son[rt][0]]+1==v) return rt;
	return kth(son[rt][1],v-siz[son[rt][0]]-1);
}
signed main(){
	//srand(time(0));
	n=read();
	for(int i=1;i<=n;i++){
		int t=read(),opt=read(),x=read(),y=0,z=0,w=0;
		root[i]=root[t];
		if(opt==1) split(root[i],y,z,x),root[i]=merge(merge(y,build(x)),z);
		if(opt==2) split(root[i],y,z,x),split(y,y,w,x-1),w=merge(son[w][0],son[w][1]),root[i]=merge(merge(y,w),z); 
		if(opt==3) split(root[i],y,z,x-1),printf("%lld\n",siz[y]+1),root[i]=merge(y,z);
		if(opt==4) printf("%lld\n",val[kth(root[i],x)]);
		if(opt==5){
			split(root[i],y,z,x-1);
			if(y) printf("%lld\n",val[kth(y,siz[y])]),root[i]=merge(y,z);
			else printf("-2147483647"),root[i]=merge(y,z);
		}
		if(opt==6){
			split(root[i],y,z,x);
			if(z) printf("%lld\n",val[kth(z,1)]),root[i]=merge(y,z);
			else printf("2147483647"),root[i]=merge(y,z);
		}
	}return 0;
} 
<think>好的,用户想了解可持久化Treap的数据结构及实现方法,特别是代码部分。首先,我需要回顾一下可持久化数据结构的基本概念。可持久化数据结构能够保存历史版本,每次修改后生成新版本,而旧版本保持不变。常见的应用包括数据库版本管理、撤销操作等。 Treap本身是二叉搜索树和堆的结合,通过随机优先级维持平衡。非Treap,比如FHQ Treap,使用Split和Merge操作来避免转,这样更适合可持久化,因为转操作会改变结构,难以维护历史版本。 接下来,我需要参考用户提供的引用内容。引用3提到了非Treap可持久化的实现,特别是在Merge操作时有时不需要复制节点,这能提高效率。引用4和5讨论了Split和Merge的具体实现,以及如何查找第k大元素。引用1和2说明了可持久化的应用场景和限制,比如势能分析的数据结构不适合完全可持久化,但Treap通过非转操作可以实现。 现在需要将FHQ Treap可持久化方法分解为关键操作:Split和Merge的可持久化版本。每次修改时复制路径上的节点,保持旧版本的结构不变。例如,在Split时,如果当前节点需要被分割,就创建新节点复制原节点的内容,然后递归处理左右子树。Merge操作类似,根据优先级决定合并方式,必要时复制节点。 代码实现部分,节点结构需要左右子节点、大小和优先级。Split函数返回分割后的两个根节点,Merge函数合并两个Treap。插入和删除操作通过Split和Merge的组合实现,每次操作生成新版本。需要注意在修改路径上的节点时创建新副本,避免影响旧版本。 可能的问题点:确保每次操作只复制必要的节点,以节省空间。例如,在Merge时,如果子树来自同一版本,可能不需要复制。此外,路径复制可能导致额外的内存消耗,需要合理管理节点的创建和更新。 最后,需要验证示例代码的正确性,比如插入操作是否正确分割和合并,并生成新版本。测试用例可以帮助确认可持久化功能是否正常,例如插入元素后检查旧版本是否存在,新版本是否正确。</think>### 可持久化Treap(FHQ Treap)数据结构及实现方法 #### 一、核心设计原理 可持久化Treap通过**路径复制**实现版本管理,每次插入/删除操作时,仅复制涉及修改的节点路径,未修改的子树直接复用。基于非转的FHQ Treap实现,核心操作包括: 1. **带复制的分裂(Split)** 递归复制路径节点,返回两个新子树 $$ \text{Split}(root, key) \rightarrow (left\_tree, right\_tree) $$ 2. **带复制的合并(Merge)** 根据优先级合并子树,复用未修改部分 $$ \text{Merge}(x, y) \rightarrow new\_root $$ #### 二、代码实现(C++示例) ```cpp struct Node { int val, prio, size; Node *ch[2]; // ch[0]左子树, ch[1]右子树 Node(int v) : val(v), prio(rand()), size(1) { ch[0] = ch[1] = nullptr; } Node(const Node& o) { // 复制构造函数 val = o.val; prio = o.prio; size = o.size; ch[0] = o.ch[0]; ch[1] = o.ch[1]; } }; // 分裂操作(返回新版本的两棵子树) pair<Node*, Node*> Split(Node* p, int key) { if (!p) return {nullptr, nullptr}; Node* new_p = new Node(*p); // 关键复制操作[^3] if (key < new_p->val) { auto [left, right] = Split(new_p->ch[0], key); new_p->ch[0] = right; update_size(new_p); // 更新子树大小 return {left, new_p}; } else { auto [left, right] = Split(new_p->ch[1], key); new_p->ch[1] = left; update_size(new_p); return {new_p, right}; } } // 合并操作(生成新版本根节点) Node* Merge(Node* x, Node* y) { if (!x) return y; if (!y) return x; if (x->prio < y->prio) { Node* new_x = new Node(*x); // 复制节点[^5] new_x->ch[1] = Merge(new_x->ch[1], y); update_size(new_x); return new_x; } else { Node* new_y = new Node(*y); new_y->ch[0] = Merge(x, new_y->ch[0]); update_size(new_y); return new_y; } } // 插入操作(返回新版本根节点) Node* Insert(Node* root, int val) { auto [L, R] = Split(root, val); Node* new_node = new Node(val); return Merge(Merge(L, new_node), R); } ``` #### 三、关键优化点 1. **延迟复制机制**:仅在Split/Merge路径上复制节点,未修改子树直接复用[^3] 2. **版本共享策略**:新旧版本共享未修改的子树结构,空间复杂度为$O(m \log n)$(m为操作次数) 3. **平衡性保障**:通过随机优先级维持树高期望$O(\log n)$[^5] #### 四、应用场景 - 数据库事务版本管理(支持回滚操作) - 文本编辑器中的无限撤销/重做功能 - 函数式编程中的持久化集合[^1]
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值