带旋 Treap树堆 洛谷P3369

已于 2023-11-29 22:52:03 修改
阅读量109 收藏
点赞数
文章标签： 算法 数据结构 c++
于 2023-11-22 21:42:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_16762209/article/details/134563413
版权

带旋treap非常简单，因为其平衡条件非常简单。只是通过旋转让fix满足即可，如果认真学习了AVL树和RB树，看到定义之后就能脑子中有一个大概明白的实现。

定义：

1.节点定义不仅有key还有一个随机值fix

2.key满足二叉排序树

3.fix满足堆

因为treap用了随机数的机制，所以不容易被卡，能保持比较好的效率。常数比较小，也因为平衡条件简单，可以进行树合并和树分裂。

treap真的实现很简单，AVL，RB，B，splay，treap中实现最简单的应该就是treap，毕竟splay还需要六种旋转（追求一点效率的话）。

定义：

struct Treapnode{
    int key,fix,Size;
    Treapnode*left,*right;
};

class Treap{
private:
    Treapnode*root;
    unsigned int Size;
    bool result;

public:
    Treap(){
        root=new Treapnode;
        root->left=root->right=root;//空指针全部指向头结点
        root->fix=-RAND_MAX;//把头结点置为最小值
        root->Size=0;
        srand(114514);//随机化
    }

查询函数：

    Treapnode*search(int x)
    {
        auto*p=root->left,*q=root;

        while(p!=root)
        {
            if(p->key==x)return p;
            q=p;
            if(p->key>x)p=p->left;
            else p=p->right;
        }

        return nullptr;
    }

辅助函数：


    void Rrotate(Treapnode*&now)
    {
        Treapnode*left=now->left;
        now->left=left->right;
        left->right=now;
        now=left;
        update(now->right),update(now);
    }

    void Lrotate(Treapnode*&now)
    {
        Treapnode*right=now->right;
        now->right=right->left;
        right->left=now;
        now=right;
        update(now->left),update(now);
    }
    void update(Treapnode*now)
    {
        if(now==root)return;
        now->Size=now->left->Size+now->right->Size+1;
    }

插入函数：

策略：找到插入位置之后，创建新节点，之后递归检查是否需要通过旋转调整fix值。

    bool insert(int x)
    {
        result=false;
        insert(root->left,x);
        return result;
    }

    void insert(Treapnode*&now,int &key)//只有插入时需要旋转
    {
        if(now==root)
        {
            now=new Treapnode;
            now->fix=rand()+RAND_MAX;//避免为负数
            now->left=now->right=root;
            now->key=key;
            now->Size=1;
            result=true;
            return;
        }
        else if(now->key>key)insert(now->left,key);
        else insert(now->right,key);//允许重复插入

        check(now);//检查，并更新Size
    }

    void check(Treapnode*&now)
    {
        if(now->fix<now->left->fix)//左孩子大，右旋
            Rrotate(now);
        else if(now->fix<now->right->fix)//右孩子大，左旋
            Lrotate(now);
        else
            update(now);//不然更新Size，
    }

删除函数：

根据treap定义可以知道，找到删除位置之后，把如果只有一个孩子替代即可，不然找前驱，替代之，然后直接删除前驱即可。整个删除函数均不需要旋转（我写的版本，实际上如果删除策略为：把待删除节点旋转至叶子，之后直接删除的话，有多次旋转，这样处理的Treap，随机性可能更好。）

    bool erase(int x)
    {
        result=false;
        erase(root->left,x);
        return result;
    }
    void SuccessOr(Treapnode*&now,int&key)//寻找继任者，赋值，之后移除
    {
        if(now->right==root)
        {
            Treapnode*temp=now;
            now=now->left;//注意写法，这是引用型参数的意义
            key=move(temp->key);
            delete temp;
            return;
        }

        SuccessOr(now->right,key);

        update(now);//更新Size即可，不需要旋转
    }

    void erase(Treapnode*&now,int &key)//删除函数中，从头至尾根本不需要旋转
    {
        if(now==root)
        {
            result=false;
            return;
        }
        else if(now->key>key)erase(now->left,key);
        else if(now->key<key)erase(now->right,key);
        else
        {
            if(now->left==root)
            {
                Treapnode*temp=now;
                now=now->right;
                delete temp;
                return;
            }
            else if(now->right==root)
            {
                Treapnode*temp=now;
                now=now->left;
                delete temp;
                return;
            }
            else
            {
                SuccessOr(now->left,now->key);
            }
        }

        update(now);
        return;
    }

全部代码：

#include <iostream>
#include <algorithm>
#include <random>

#define ll long long

using namespace std;

//要求key大于左子树，小于右子树，fix大于两者
//思想：key的性质由二叉排序树保证，fix由旋转保证，而由fix引起的旋转保证了树的高度较低水平
//方法：左孩子fix大，右旋，右孩子fix大，左旋。很简单吧，删除的时候直接寻找继任者，根本不需要旋转

struct Treapnode{
    int key,fix,Size;
    Treapnode*left,*right;
};

class Treap{
private:
    Treapnode*root;
    unsigned int Size;
    bool result;

public:
    Treap(){
        root=new Treapnode;
        root->left=root->right=root;//空指针全部指向头结点
        root->fix=-RAND_MAX;//把头结点置为最小值
        root->Size=0;
        srand(114514);//随机化
    }

    bool insert(int x)
    {
        result=false;
        insert(root->left,x);
        return result;
    }

    bool erase(int x)
    {
        result=false;
        erase(root->left,x);
        return result;
    }

    Treapnode*search(int x)
    {
        auto*p=root->left,*q=root;

        while(p!=root)
        {
            if(p->key==x)return p;
            q=p;
            if(p->key>x)p=p->left;
            else p=p->right;
        }

        return nullptr;
    }

    int get_rank(int x)
    {
        auto*now=root->left;
        int rank=1;

        while(now!=root&&now!=nullptr)
        {
            if(x<=now->key)
                now=now->left;
            else
            {
                rank+=now->left->Size+1;
                now=now->right;
            }
        }

        return rank;
    }
    int get_val(int rank)
    {
        auto*now=root->left;

        while(now!=root&&now!=nullptr)
        {
            if(now->left->Size+1==rank)
                break;
            else if(now->left->Size>=rank)
                now=now->left;
            else
            {
                rank-=now->left->Size+1;
                now=now->right;
            }
        }

        return now->key;
    }
    int get_pre(int x)
    {
        auto*p=root->left;
        int pre;

        while(p!=root&&p!=nullptr)
        {
            if(p->key<x)pre=p->key,p=p->right;
            else p=p->left;
        }

        return pre;
    }

    int get_next(int x)
    {
        auto*p=root->left;
        int next;

        while(p!=root&&p!=nullptr)
        {
            if(p->key>x)next=p->key,p=p->left;
            else p=p->right;
        }

        return next;
    }

private:

    void update(Treapnode*now)
    {
        if(now==root)return;
        now->Size=now->left->Size+now->right->Size+1;
    }

    void SuccessOr(Treapnode*&now,int&key)//寻找继任者，赋值，之后移除
    {
        if(now->right==root)
        {
            Treapnode*temp=now;
            now=now->left;//注意写法，这是引用型参数的意义
            key=move(temp->key);
            delete temp;
            return;
        }

        SuccessOr(now->right,key);

        update(now);//更新Size即可，不需要旋转
    }

    void erase(Treapnode*&now,int &key)//删除函数中，从头至尾根本不需要旋转
    {
        if(now==root)
        {
            result=false;
            return;
        }
        else if(now->key>key)erase(now->left,key);
        else if(now->key<key)erase(now->right,key);
        else
        {
            if(now->left==root)
            {
                Treapnode*temp=now;
                now=now->right;
                delete temp;
                return;
            }
            else if(now->right==root)
            {
                Treapnode*temp=now;
                now=now->left;
                delete temp;
                return;
            }
            else
            {
                SuccessOr(now->left,now->key);
            }
        }

        update(now);
        return;
    }

    void insert(Treapnode*&now,int &key)//只有插入时需要旋转
    {
        if(now==root)
        {
            now=new Treapnode;
            now->fix=rand()+RAND_MAX;//避免为负数
            now->left=now->right=root;
            now->key=key;
            now->Size=1;
            result=true;
            return;
        }
        else if(now->key>key)insert(now->left,key);
        else insert(now->right,key);//允许重复插入

        check(now);//检查，并更新Size
    }

    void check(Treapnode*&now)
    {
        if(now->fix<now->left->fix)//左孩子大，右旋
            Rrotate(now);
        else if(now->fix<now->right->fix)//右孩子大，左旋
            Lrotate(now);
        else
            update(now);//不然更新Size，
    }

    void Rrotate(Treapnode*&now)
    {
        Treapnode*left=now->left;
        now->left=left->right;
        left->right=now;
        now=left;
        update(now->right),update(now);
    }

    void Lrotate(Treapnode*&now)
    {
        Treapnode*right=now->right;
        now->right=right->left;
        right->left=now;
        now=right;
        update(now->left),update(now);
    }
};

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);

    Treap it;
    int n;
    cin>>n;

    while(n--)
    {
        int op,x;
        cin>>op>>x;

        if(op==1)
        {
            it.insert(x);
        }
        else if(op==2)
        {
            it.erase(x);
        }
        else if(op==3)
        {
            cout<<it.get_rank(x)<<'\n';
        }
        else if(op==4)
        {
            cout<<it.get_val(x)<<'\n';
        }
        else if(op==5)
        {
            cout<<it.get_pre(x)<<'\n';
        }
        else if(op==6)
        {
            cout<<it.get_next(x)<<'\n';
        }
        else if(op==7)
        {
            cout<<it.search(x)->key<<endl;
        }
        
    } 
    cout<<endl;
    system("pause");
    return 0;
}

洛谷P3369AC记录（常数小就是好，没开O2）：

其他平衡树

手搓平衡树：一颗B-树，一颗AVL树，一颗RB树，一颗Splay树，一颗带旋Treap，一颗无旋fhq-Treap，一颗01Trie-优快云博客

DogDu
关注
无旋treap/fhq-treap 模板 （附良心讲解 + 例题：洛谷P3369 普通平衡树）
shadiao.的博客
09-09 808
博文更新： 20190917 更新了一下merge和split函数的递归理解 定义： 无旋treap，就是不通过旋转的维护堆性质的treap，根本的原理还是 tree + heap。 与普通treap的不同之处： 大概就是可以可持久化。 然后区间操作的话，不知道有旋的行不行，用无旋的反正是比较好搞，区间操作举个例子就是让你把一段区间的数反过来等等。 现在听着可能区间操作什么的可能莫名...
洛谷 P2286 [HNOI2004]宠物收养场 (treap 树)
qq_38232157的博客
09-21 221
treap 树 本题要点： 1、建立两棵 treap 树， 一棵用来存 宠物，一棵树用来存 顾客。 题目给出的所有的顾客值和宠物值都不一样。 这样结构体 Treap 只需要 多一个 size 来就来子树的节点总数 2、套用 treap 树 的模板，写好 以下函数。 因为是两棵树，需要传参数的引用。 int New(int val, Treap* a, int& tot) void update(int p, Treap* a) void Build(Treap* a, int& tot,
洛谷 P2073 送花
weixin_30586257的博客
08-22 153
题目背景 小明准备给小红送一束花，以表达他对小红的爱意。他在花店看中了一些花，准备用它们包成花束。 题目描述 这些花都很漂亮，每朵花有一个美丽值W，价格为C。 小明一开始有一个空的花束，他不断地向里面添加花。他有以下几种操作： 操作 含义 1 W C 添加一朵美丽值为W，价格为C的花。 3 小明觉得当前花束中最便宜的一朵花太廉价，不适合送给小红，所以删除最便宜的一朵花。 2 小明觉...
【洛谷 P3369】 普通平衡树【平衡树 Treap】
在人间贩卖声音
08-18 521
解题思路 平衡树：利用BST性质查询和修改，利用随机和堆优先级来保持平衡，把树的深度控制在log N，保证了操作效率 基本平衡树有以下几个比较重要的函数：新建，插入，删除，旋转 节点的基本属性有val(值)，dat(随机出来的优先级) 通过增加属性，结合BST的性质可以达到一些效果，如size(子树大小，查询排名)，cnt(每个节点包含的副本数)等 由于每个操作用代码比较好介绍，这里就直接放代码介绍： int ch[maxn][2];//[i][0]代表i左儿子，[i][1]代表i右儿子 新增节点...
Treap树 ← 洛谷P3369、AcWing253
hnjzsyjyj的专栏
05-06 738
●​​​​​​​Treap 树是一种原理比较简单的 BST。Treap=Tree+Heap，即 Treap 是树和堆（大根堆或小根堆）的结合，通常翻译成树堆。 ●Treap 树的操作基于“键值 val + 优先级 pri”。Treap 树的每个结点包含两个信息 (val, pri)，对于 val，它是一个BST（二叉查找树），对于 pri，它是一个堆（大根堆或小根堆）。
洛谷P3391 文艺平衡树 treap或splay
FairyTail0423的专栏
09-22 265
网址：https://www.luogu.org/problem/P3391 题意： 给出一个数列，$a_i=i$，维护数列的区间翻转，输出所有翻转后的结果。 题解： 一、treap解法： 涉及区间翻转的$treap$解法只能使用无旋$treap$，将无旋$treap$分裂成三棵子树，分别是区间左，区间和区间右，然后给区间打上标记然后交换子树，在$merge$的时候下传标记即可...
洛谷 2234 [HNOI2002]营业额统计——treap（入门）
weixin_34326179的博客
03-01 191
题目：https://www.luogu.org/problemnew/show/P2234 学习了一下 treap 的写法。 学习材料：https://blog.youkuaiyun.com/litble/article/details/78934306 　　　　　http://memphis.is-programmer.com/posts/46317.html 　　　　　https://www.c...
无旋 fhq-Treap树堆 洛谷P3369
qq_16762209的博客
11-22 133
无旋fhq-Treap，洛谷P3369
fhq treap入门
qq_35577488的博客
03-23 865
目录一.前言二.原理三.具体实现模板题目一.洛谷P3369:普通平衡树二.洛谷P3391 文艺平衡树 一.前言 这个数据结构早有耳闻.只是一直没学.跟着AgOH学了一波.发现很简单. 二.原理 二叉搜索树之所以不够优秀,是因为存在一些数据能够将二叉搜索树退化成一条链.从而导致平方级的复杂度.那么对于这个缺陷,大佬们想出了很多方法去解决,衍生出了①替罪羊树②有旋/无旋Treap③splay.今天我入门学习的就是无旋treap. Treap之所以能够克服二叉搜索树的缺陷,主要因为它以随机的方式构造二叉搜索树.使
简析平衡树（二）——Treap
CXR的博客
08-03 4570
前言 学完了替罪羊树，我决定再去学一学TreapTreapTreap。一直听说TreapTreapTreap很难，我也花了挺久才学会。 简介 TreapTreapTreap这个名字真的挺有内涵： TreeTree\color{red}{Tree}+HeapHeap\color{blue}{Heap}=TreTre\color{red}{Tre}+eapeap\color{blue}{e...
洛谷 P2234 [HNOI2002]营业额统计（算法竞赛进阶指南，平衡树）
qq_38232157的博客
06-25 443
算法竞赛进阶指南，238页，平衡树 本题要点： 1、该天的最小波动值=min{|该天以前某一天的营业额-该天营业额|}。 每天的最小波动值， 实际就是改天的营业额 cur 和之前的所有营业额一起排序，计算出 cur 与相邻两个营业额 之间的差值的较小值，就是 该天的最小波动值 2、平衡树容易满足，每天的营业额 income 插入到这颗 平衡树中，计算出 income 的前驱 pre 和后继 next， 该天的最小波动值 = min( abs(income - pre), abs(income, next))
洛谷 P2596 [ZJOI2006]书架 (平衡树,fhq treap详解)
weixin_45590210的博客
09-17 312
传送门 fhq treap对于区间的操作可谓是很简单很暴力,但是在没有完全理解fhq treap之前可能会对区间操作一脸懵.这篇博客希望能帮助到大家理解fhq treap的区间操作. 我们要明确一个点,fhq treap维护平衡的方式就是split和merge操作,这两个操作保证和平衡树的性质.但这是按值分裂的fhq treap所采取的方式.而区间操作就显得更加暴力了,说是一颗平衡树,其实又不太像广义上面的平衡树.树的分裂不是靠值,而是靠大小(这就很强了).所谓的建树,只是把一个一个的结点拼接起来.先拼接的
FHQ-Treap学习笔记 / 洛谷 P2042 / bzoj1500 【FHQ-Treap】【栈】
willem248的博客
08-25 215
merge操作：合并两棵FHQ-Treap。类似于启发式合并，在两棵Treap中找到根节点key值最大的根节点，然后继续递归处理即可。FHQ-Treap可以解决的问题：splay能解决的除了LCT以外的所有问题。FHQ-Treap和普通的Treap一样，都有两个值key和val。split操作：在一个FHQ-Treap中拆出value最小的。FHQ-Treap有两种操作，分别是merge和split。个节点变成两棵FHQ-Treap。那么在根节点上（不需特判），如果。那么根在左儿子上，如果。
FHQ Treap入门教程（含洛谷P3369 & LOJ#104 普通平衡树题解qwq）
The_OIer的博客
09-01 389
前置技能 二叉搜索树 堆 前置技能有旋转treap？不存在的（我到现在仍然不会旋转的treap qwq） Treap简介 引用维基百科上一句精辟的话：Treap=Tree+Heap 在Treap上需要维护两个值：一个优先级pripripri，一个节点权值valvalval。 其中优先级取随机数，满足小根堆的性质。节点权值满足二叉搜索树的性质。 即每个节点的pripripri值均小于左、右孩子的pr...
高被引二区优化算法——肝癌算法（Liver Cancer Algorithm，LCA）深度解析+性能测试
woaipythonmeme的博客
05-19 622
LCA的核心机制聚焦于肿瘤在寻找最有利生存环境时所表现出的适应性与侵袭性行为，算法通过演化搜索策略再现肝癌细胞在器官中逐步扩张并主导空间的动态机制，其数学建模确保了算法在解空间内的全局探索能力与局部开采能力之间的高效平衡。为确定肿瘤的体积，我们采用一种基于数学模型的计算方法，假设肿瘤呈半椭球形，该形态已在包括肝癌在内的多种癌症中被观察到。在LCA算法的该阶段中，其设计灵感源自真实肿瘤的扩散过程，假设肿瘤可在竞争环境中逐步选择最优路径深入肝脏的不同区域以实现侵占。）时，目标代理元素的肿瘤位置将被考虑。
代码随想录算法训练营第60期第三十九天打卡
2401_83782806的博客
05-17 792
首先我们就直接看到这一道题目，看看我们是否可以发现究竟在考查哪一个算法：我们来看一下题意，就是我们有一堆石头，我们每一次可以选出任意两块石头并将其一起粉碎，如果两块石头的重量相同那么两块石头都会被完全粉碎，如果一块石头重量大一块石头重量小的话，那么我们重量小的石头会被完全粉碎，大的石头剩下的重量是大的石头减去小的石头，最后我们只会剩下一块石头，那么题目要求我们返回此石头的最小的可能重量，如果没有剩余就返回0，那么我们应该如何思考这一道题目呢？
算法-数对的使用
最新发布
2303_80050865的博客
05-19 51
【代码】算法-数对的使用。
【背包dp】小结
2401_82676816的博客
05-18 589
多个物品选几个，容量限制是核心；选或不选看约束，价值最大找最优；可重复用正序扫，只能选一次就倒流；多重拆成 0-1 背，分组记得内部分组选。
算法练习：19.JZ29 顺时针打印矩阵
qq_34348690的博客
05-16 324
【代码】算法练习：19.JZ29 顺时针打印矩阵。
Treap树堆的可视化动态实现
- 旋转操作（Rotate）：旋转是Treap树堆中最核心的操作之一，它分为左旋（Left Rotate）和右旋（Right Rotate）两种基本形式。通过旋转，可以在不破坏二叉搜索树性质的前提下，调整树的高度，使得树尽可能平衡。 3....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

DogDu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值