非旋转treap模板

先占坑


免责声明:本人由于同学zawedx神犇的带领喜欢缩♂行,若观看带来不适感,本人不负任何责任。
模板题bzoj 3224 普通平衡树
主要思(suo)想(hang)是把求value x在集合里面的rank的时候,视作求x-1的最小的后继(这样我们就能少打一个函数=w=)
pre和nxt都是pair类型,first和second分别代表的是前驱(后继)的rank和值
代码写的有点……难以看懂
看我不爽的可以去看看我的同学的代码,这样你看我的会舒服点(雾)

#include<cstdio>
#include<cstdlib>
#include<algorithm>
using namespace std;
#define maxn 100100
#define L(x) t[x].ls
#define R(x) t[x].rs
int Q,opt,x,root,cnt,Re,F;
char ch;
struct pnt{int val,key,ls,rs,siz;}t[maxn];
typedef pair<int,int> P;
inline int read(){
    for(Re=F=0,ch=getchar();(ch<'0'||ch>'9')&&ch!='-';ch=getchar());
    if(ch=='-')F=1,ch=getchar();
    for(;'0'<=ch&&ch<='9';ch=getchar())Re=(Re<<3)+(Re<<1)+ch-'0';
    return F?-Re:Re;
}
inline int upd(int x){t[x].siz=t[t[x].ls].siz+t[t[x].rs].siz+1;return x;}
int merge(int x,int y){
    if(!x||!y)return x|y;
    if(t[x].key<t[y].key)return R(x)=merge(R(x),y),upd(x);
    else return L(y)=merge(x,L(y)),upd(y);
}
P split(int x,int k){
    if(k==0)return P(0,x);
    int l=t[x].ls,r=t[x].rs;
    if(t[l].siz==k)return L(x)=0,P(l,upd(x));
    if(t[l].siz+1==k)return R(x)=0,P(upd(x),r);
    if(k<t[L(x)].siz){
        P tmp=split(l,k);
        return L(x)=tmp.second,P(tmp.first,upd(x));
    }
    P tmp=split(r,k-t[l].siz-1);
    return R(x)=tmp.first,P(upd(x),tmp.second);
}
inline P nxt(int x){
    P tmp(1,2047483647);
    for(int now=root;now;)
        if(t[now].val<=x)tmp.first+=t[L(now)].siz+1,now=R(now);
        else tmp.second=min(t[now].val,tmp.second),now=L(now);
    return tmp;
}
inline P pre(int x){
    P tmp(t[root].siz,-2047483647);
    for(int now=root;now;)
        if(t[now].val>=x)tmp.first-=t[R(now)].siz+1,now=L(now);
        else tmp.second=max(t[now].val,tmp.second),now=R(now);
    return tmp;
}
inline void ins(int x){
    P tmp=split(root,nxt(x-1).first-1);
    t[++cnt]=(pnt){x,rand(),0,0,1};
    root=merge(merge(tmp.first,cnt),tmp.second);
}
inline void del(int x){
    P tmp=split(root,nxt(x-1).first-1);
    root=merge(tmp.first,split(tmp.second,1).second);
}
int num(int x){
    for(int now=root;now;){ 
        if(t[L(now)].siz==x-1)return t[now].val;
        else if(t[L(now)].siz>=x)now=L(now);
        else x-=t[L(now)].siz+1,now=R(now);
    } 
}
int main(){
    srand(20010426);
    for(Q=read();Q--;){
        switch(read()){
        case 1:ins(read());break;
        case 2:del(read());break;
        case 3:printf("%d\n",nxt(read()-1).first);break;
        case 4:printf("%d\n",num(read()));break;
        case 5:printf("%d\n",pre(read()).second);break;
        case 6:printf("%d\n",nxt(read()).second);break;
        }
    }
}

模板题2 bzoj 3223 文艺平衡树 容易发现翻转操作对某一整块翻转偶数次之后,只改变其位置而不改变其内部元素顺序。故对每个节点增加一个Flag标记,用^1维护就好了。

#include<cstdio>
#include<algorithm>
#include<cstdlib>
using namespace std;
#define maxn 100100
#define P pair<int,int>
#define L(x) t[x].ls
#define R(x) t[x].rs
#define F(x) t[x].f
int l,r,m,n,cnt,root;
struct pnt{int val,key,S,ls,rs;bool f;}t[maxn];
inline int U(int x){t[x].S=t[L(x)].S+t[R(x)].S+1;return x;}
inline int ps(int x){if(F(x))swap(L(x),R(x)),F(L(x))^=1,F(R(x))^=1,F(x)^=1;return x;}
void get(int &a,int &b,P pp){a=pp.first,b=pp.second;}
int meg(int x,int y){
    return !x||!y?x|y:t[x].key<t[y].key?
    (R(ps(x))=meg(R(x),y),U(x)):
    (L(ps(y))=meg(x,L(y)),U(y));
}
P spl(int x,int k){
    if(!k)return P(0,x);
    int T=k-t[L(ps(x))].S-1;
    return T>=0?(get(R(x),T,spl(R(x),T)),P(U(x),T)):
    (get(T,L(x),spl(L(x),k)),P(T,U(x)));
}
void prf(int x){
    if(t[ps(x)].S==1)printf("%d ",t[x].val);
    else if(x)prf(L(x)),printf("%d ",t[x].val),prf(R(x));
}
int main(){
    scanf("%d%d",&n,&m);
    srand(20010426);
    for(int i=1;i<=n;i++)t[++cnt]=(pnt){i,rand(),1,0,0},root=meg(root,cnt);
    while(m--){
        scanf("%d%d",&l,&r);
        P tmp=spl(root,l-1);
        P lsh=spl(tmp.second,r-l+1);
        F(lsh.first)^=1;
        root=meg(meg(tmp.first,lsh.first),lsh.second);
    }
    prf(root);
}
Treap(Tree + Heap)是一种结合了二叉搜索树(BST)和堆(Heap)特性的平衡二叉搜索树数据结构。其核心原理在于每个节点维护两个值:一个用于二叉搜索树性质的键值(key),以及一个用于最大堆性质的优先级(priority)。通过这两个属性,Treap在插入和删除操作时保持树的平衡性,从而确保操作的时间复杂度接近于对数级别。 ### Treap的基本原理 1. **二叉搜索树性质**:对于任意节点,其左子树中所有节点的键值小于当前节点的键值,右子树中所有节点的键值大于当前节点的键值。 2. **堆性质**:每个节点的优先级大于其子节点的优先级,这样可以确保树的结构在插入或删除时通过旋转操作保持平衡。 在插入新节点时,Treap首先按照二叉搜索树的方式找到合适的位置,并赋予该节点一个随机的优先级。如果该节点的优先级违反了堆性质,则通过旋转操作调整树的结构以恢复堆性质。删除操作类似,通过旋转确保堆性质得以维持。 ### 无旋Treap的实现 无旋Treap(Non-Rotating Treap)是Treap的一个变种,它通过分裂(Split)和合并(Merge)操作来实现树的平衡,而不是传统的旋转操作。分裂操作将树按照某个键值或位置分割为两部分,而合并操作将两个树合并为一个。这种方式简化了实现逻辑,尤其是在处理复杂操作时[^2]。 例如,分裂操作可以通过以下方式实现(以键值为分割点): ```python def split(node, key): if node is None: return (None, None) if node.key <= key: left, right = split(node.right, key) node.right = left return (node, right) else: left, right = split(node.left, key) node.left = right return (left, node) ``` 合并操作则需要确保堆性质的维护: ```python def merge(left, right): if left is None: return right if right is None: return left if left.priority > right.priority: left.right = merge(left.right, right) return left else: right.left = merge(left, right.left) return right ``` ### 应用场景 Treap由于其高效的平衡特性,广泛应用于需要高效查找、插入和删除操作的场景。常见的应用包括: - **数据库索引**:Treap可以用于实现高效的索引结构,支持快速的数据检索。 - **内存中的集合与映射**:在需要频繁插入和删除元素的场景中,Treap提供了良好的性能保障。 - **算法竞赛**:在某些需要高效数据结构的竞赛题中,Treap常被用来实现动态集合操作[^1]。 ### 实现细节 在实现Treap时,需要注意以下几点: - **随机优先级生成**:为了保证树的平衡性,每个节点的优先级应随机生成,通常使用大范围的整数以减少冲突的可能性。 - **递归与递归实现**:虽然递归实现较为直观,但在大规模数据处理时可能会导致栈溢出,因此在实际应用中可以考虑递归实现。 - **类型安全与内存管理**:特别是在使用Rust等语言时,需注意类型约束和内存安全,以确保程序的稳定性和可靠性[^1]。 通过理解Treap的原理和实现方式,开发者可以更好地将其应用于实际项目中,并根据需求进行扩展和优化。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值