Treap

最新推荐文章于 2023-05-06 22:22:39 发布
最新推荐文章于 2023-05-06 22:22:39 发布
阅读量103 收藏
点赞数
分类专栏： 算法 文章标签： treap 平衡树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46126537/article/details/119007060
版权

普通平衡树

在这里插入图片描述
一道平衡树模板题
在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
const int N=1e5+10,INF=1e8;
struct node
{
    int l,r;
    int key,val;
    int cnt;
    int size;
}tr[N];
int root,idx;
void pushup(int p)
{
    tr[p].size=tr[tr[p].l].size+tr[tr[p].r].size+tr[p].cnt;
}
int get_node(int key)
{
    tr[++idx].key=key;
    tr[idx].val=rand();
    tr[idx].cnt=tr[idx].size=1;
    return idx;
}
void zig(int &p) // 右旋
{
    int q = tr[p].l;
    tr[p].l = tr[q].r, tr[q].r = p, p = q;
    pushup(tr[p].r), pushup(p);
}
void zag(int &p) // 左旋
{
    int q = tr[p].r;
    tr[p].r = tr[q].l, tr[q].l = p, p = q;
    pushup(tr[p].l), pushup(p);
}
void build()
{
    get_node(-INF),get_node(INF);
    root=1,tr[1].r=2;
    pushup(1);
    if (tr[1].val < tr[2].val) zag(root);
}
void insert(int &p,int key)
{
    if(!p) p=get_node(key);
    else if(tr[p].key==key) tr[p].cnt++;
    else if(tr[p].key>key)
    {
        insert(tr[p].l,key);
        if(tr[tr[p].l].val>tr[p].val) zig(p);
    }
    else 
    {
        insert(tr[p].r,key);
        if(tr[tr[p].r].val>tr[p].val) zag(p);
    }
    pushup(p);
}
void remove(int &p,int key)
{
    if(!p) return;
    if(tr[p].key==key)
    {
        if(tr[p].cnt>1) tr[p].cnt--;
        else if(tr[p].l||tr[p].r)
        {
            if(!tr[p].r||tr[tr[p].l].val>tr[tr[p].r].val)
            {
                zig(p);
                remove(tr[p].r,key);
            }
            else 
            {
                zag(p);
                remove(tr[p].l,key);
            }
        }
        else p=0;
    }
    else if(tr[p].key>key) remove(tr[p].l,key);
    else remove(tr[p].r,key);
    pushup(p);
}
int get_rank_by_key(int &p,int key)
{
    if(!p) return 0;
    if(tr[p].key==key) return tr[tr[p].l].size+1;
    if(tr[p].key>key) return get_rank_by_key(tr[p].l,key);
    return tr[tr[p].l].size+tr[p].cnt+get_rank_by_key(tr[p].r,key);
}
int get_key_by_rank(int &p,int rank)
{
    if(!p) return 0;
    if(tr[tr[p].l].size>=rank) return get_key_by_rank(tr[p].l,rank);
    if(tr[tr[p].l].size+tr[p].cnt>=rank) return tr[p].key;
    return get_key_by_rank(tr[p].r,rank-(tr[tr[p].l].size+tr[p].cnt));
}
int get_prev(int &p,int key)
{
    if(!p) return -INF;
    if(tr[p].key>=key) return get_prev(tr[p].l,key);
    return max(tr[p].key,get_prev(tr[p].r,key));
}
int get_next(int &p,int key)
{
    if(!p) return INF;
    if(tr[p].key<=key) return get_next(tr[p].r,key);
    return min(tr[p].key,get_next(tr[p].l,key));
}
int main()
{
    int n;
    scanf("%d",&n);
    build();
    while(n--)
    {
        int op,x;
        scanf("%d%d",&op,&x);
        if(op==1) insert(root,x);
        else if(op==2) remove(root,x);
        else if(op==3) printf("%d\n",get_rank_by_key(root,x)-1);
        else if(op==4) printf("%d\n",get_key_by_rank(root,x+1));
        else if(op==5) printf("%d\n",get_prev(root,x));
        else printf("%d\n",get_next(root,x));
    }
    return 0;
}

营业额统计

在这里插入图片描述
就这道题来说，不必要使用平衡树来解决
用这道题练习平衡树

简单分析一下会发现这道题一点不难，只需要用平衡树支持三个操作就可以

  • 插入一个数
  • 找小于这个数的最大数
  • 找大于这个数的最小数

由此就可以用上面的模板来解决这道题了

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 4e4, INF = 1e8;
int n;
struct Node
{
    int l, r;
    int key, val;
} tr[N];
int root, idx;
int get_node(int key)
{
    tr[++idx].key = key;
    tr[idx].val = rand();
    return idx;
}
void build()
{
    get_node(-INF), get_node(INF);
    root = 1, tr[1].r = 2;
}
void zig(int &p)
{
    int q = tr[p].l;
    tr[p].l = tr[q].r, tr[q].r = p, p = q;
}
void zag(int &p)
{
    int q = tr[p].r;
    tr[p].r = tr[q].l, tr[q].l = p, p = q;
}
void insert(int &p, int key)
{
    if (!p)
        p = get_node(key);
    else if (tr[p].key == key)
        return;
    else if (tr[p].key > key)
    {
        insert(tr[p].l, key);
        if (tr[tr[p].l].val > tr[p].val)
            zig(p);
    }
    else
    {
        insert(tr[p].r, key);
        if (tr[tr[p].r].val > tr[p].val)
            zag(p);
    }
}
int get_prev(int p, int key)
{
    if (!p)
        return -INF;
    if (tr[p].key > key)
        return get_prev(tr[p].l, key);
    return max(tr[p].key, get_prev(tr[p].r, key));
}
int get_next(int p, int key)
{
    if (!p)
        return INF;
    if (tr[p].key < key)
        return get_next(tr[p].r, key);
    return min(tr[p].key, get_next(tr[p].l, key));
}
int main()
{
    build();
    scanf("%d", &n);
    ll res = 0;
    for (int i = 0; i < n; i++)
    {
        int x;
        scanf("%d", &x);
        if (i == 0)
            res += x;
        else
            res += min(x - get_prev(root, x), get_next(root, x) - x);
        insert(root, x);
    }
    printf("%lld\n", res);
    return 0;
}

宠物收养所

在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
const int N=1e5+10,INF=2e8,MOD=1e6;
struct node
{
    int l,r;
    int key,val;
    int cnt;
    int size;
}tr[N];
int root,idx;
void pushup(int p)
{
    tr[p].size=tr[tr[p].l].size+tr[tr[p].r].size+tr[p].cnt;
}
int get_node(int key)
{
    tr[++idx].key=key;
    tr[idx].val=rand();
    tr[idx].cnt=tr[idx].size=1;
    return idx;
}
void zig(int &p) // 右旋
{
    int q = tr[p].l;
    tr[p].l = tr[q].r, tr[q].r = p, p = q;
    pushup(tr[p].r), pushup(p);
}
void zag(int &p) // 左旋
{
    int q = tr[p].r;
    tr[p].r = tr[q].l, tr[q].l = p, p = q;
    pushup(tr[p].l), pushup(p);
}
void build()
{
    get_node(-INF),get_node(INF);
    root=1,tr[1].r=2;
    pushup(1);
    if (tr[1].val < tr[2].val) zag(root);
}
void insert(int &p,int key)
{
    if(!p) p=get_node(key);
    else if(tr[p].key==key) tr[p].cnt++;
    else if(tr[p].key>key)
    {
        insert(tr[p].l,key);
        if(tr[tr[p].l].val>tr[p].val) zig(p);
    }
    else 
    {
        insert(tr[p].r,key);
        if(tr[tr[p].r].val>tr[p].val) zag(p);
    }
    pushup(p);
}
void remove(int &p,int key)
{
    if(!p) return;
    if(tr[p].key==key)
    {
        if(tr[p].cnt>1) tr[p].cnt--;
        else if(tr[p].l||tr[p].r)
        {
            if(!tr[p].r||tr[tr[p].l].val>tr[tr[p].r].val)
            {
                zig(p);
                remove(tr[p].r,key);
            }
            else 
            {
                zag(p);
                remove(tr[p].l,key);
            }
        }
        else p=0;
    }
    else if(tr[p].key>key) remove(tr[p].l,key);
    else remove(tr[p].r,key);
    pushup(p);
}
int get_prev(int &p,int key)
{
    if(!p) return -INF;
    if(tr[p].key>=key) return get_prev(tr[p].l,key);
    return max(tr[p].key,get_prev(tr[p].r,key));
}
int get_next(int &p,int key)
{
    if(!p) return INF;
    if(tr[p].key<=key) return get_next(tr[p].r,key);
    return min(tr[p].key,get_next(tr[p].l,key));
}
int main()
{
    int n;
    int res=0;
    int mark=0;
    scanf("%d",&n);
    build();
    while(n--)
    {
        int op,x;
        scanf("%d%d",&op,&x);
        if(op==mark||tr[root].size==2)
        {
            mark=op;
            insert(root,x);
        }
        else 
        {
            int f=get_prev(root,x);
            int e=get_next(root,x);
            if(abs(f-x)>abs(e-x))
            {
                remove(root,e);
                res=(res+abs(e-x))%MOD;
            }
            else 
            {
                remove(root,f);
                res=(res+abs(f-x))%MOD;
            }
        }
    }
    cout<<res<<endl;
    return 0;
}
独孤醉人
关注
专栏目录
无旋Treap——FHQ Treap
Lucas_FC_的博客
08-29 734
FHQ Treap
treap
zjy2015302395的博客
03-20 310
http://www.spoj.com/problems/ORDERSET/ In this problem, you have to maintain a dynamic set of numbers which support the two fundamental operations INSERT(S,x): if x is not in S, insert x into S DELE
TREAP
dengtun2502的博客
05-24 134
TREAP Treap = Tree + Heap. 树堆，在数据结构中也称Treap，是指有一个随机附加域满足堆的性质的二叉搜索树，其结构相当于以随机数据插入的二叉搜索树。其基本操作的期望时间复杂度为O(logn)。相对于其他的平衡二叉搜索树，Treap的特点是实现简单，且能基本实现随机平衡的结构。 Treap 维护堆的性质的方法只用到了左旋和右旋， 编程复杂度比Splay小一点(??...
FHQ Treap
俗世客01的博客
03-01 129
FHQ Treap 主要通过 mergemergemerge 和 spiltspiltspilt 两个操作来实现。 merge merge(x,y)merge(x,y)merge(x,y) 要求 xxx 所在子树中的元素均小于等于 yyy 所在子树中的元素，将两棵树合并，并返回合并后的根节点。 inline int merge(int x,int y){ if(!x||!y)return x+y; pushdown(x),pushdown(y); if(tr[x].dat<tr[y].dat){
Treap笔记
C_eeking的博客
08-25 348
Treap的基本实现与例题笔记
【数据结构】Treap树堆
最新发布
qq_23096319的博客
05-06 642
Treap就是Tree+heap，首先有二叉搜索树（BST）的数据，treapCnt记录当前的节点总数，节点和键值的映射key，每个节点的左右儿子childs，以及一个键可能存在多个副本，用cnt记录副本数，size记录子树大小，用于查找第k大元素。堆相关的数据：每个节点的优先级priority，这个优先级在创建节点时随机生成，保证了Treap的深度不会太大。
fhq Treap
weixin_51606521的博客
02-10 1778
普通Treap，既Tree加Heap。它让平衡树上的每一个结点存放两个信息：值和一个随机的索引。其中值满足二叉搜索树的性质，索引满足堆的性质，结合二叉搜索树和二叉堆的性质来使树平衡。这也是Treap的性质。 Treap用二叉堆来维护随机索引，其实就是相当于把插入次序随机化。插入一数值后你必然要让索引去满足二叉堆的特性，但又因为索引是随机的，那就会导致插入的数后不知道搞到哪里去了，相当于插入次序随机了。 （随机大法好，吊打一切毒瘤数据） fhq Treap的奇怪操作并且是核心操作只有两个：分裂和合并
数据结构之Treap详解
09-04
【数据结构之Treap详解】 Treap是一种结合了二叉搜索树（BST）和堆（Heap）特性的数据结构，其名称由“tree”和“heap”组合而成。Treap的特点在于每个节点不仅包含键值，还包含一个优先级，这个优先级通常是随机...
基本Treap.ppt
09-17
基本Treap.ppt
图的拓扑序列
qq_46126537的博客
11-03 6205
若一个由图中所有点构成的序列A满足：对于图中的每条边(x, y)，x在A中都出现在y之前，则称A是该图的一个拓扑序列。 拓扑序列都是针对有向图而言的 将图中的节点按拓扑序列排好后，所有的边都是从前指向后的，没有反向边 只要存在环，则一定没有拓扑序列 一个有向无环图一定存在一个拓扑序列（有向无环图也叫拓扑图） 所有入度为0的点都有可能引导一个拓扑序列 一个有向无环图一定存在一个入度为0的点 有向图的拓扑序列 #include <bits/stdc++.h> using namespace std;
高斯消元法解线性方程组
qq_46126537的博客
01-01 3836
高斯消元法 对于一组线性方程组，枚举每一列进行如下步骤： 1、找到绝对值最大的一行 2、将这一行交换到第一行 3、将这一行的第一个数变成1，对当前这一行进行操作，不涉及矩阵的初等变换 4、将下面所有行的当前列全部消成0，利用矩阵的初等变换 对于原线性方程组进行变换后 如果得到的矩阵是一个完美的上三角矩阵，则说明方程组有唯一解 否则会出现两种情况： 1、推出矛盾，即：零==非零，这种情况下表示无解 2、否则，即原线性方程组中有多余的方程，此时有无穷多解 高斯消元解线性方程组 #include <bits
高斯消元法解异或线性方程组
qq_46126537的博客
01-03 988
高斯消元法 对于一组线性方程组，枚举每一列进行如下步骤： 1、找到首元非零行 2、将这一行交换到第一行 3、将这一行的第一个数变成1，对当前这一行进行操作，不涉及矩阵的初等变换 4、将下面所有行的当前列全部消成0，利用矩阵的初等变换 对于原异或方程组进行变换后 如果得到的矩阵是一个完美的上三角矩阵，则说明方程组有唯一解 否则会出现两种情况： 1、推出矛盾，即：零==非零，这种情况下表示无解 2、否则，即原异或方程组中有多余的方程，此时有无穷多解 高斯消元解异或线性方程组 #include <bits/
DFS深度优先搜索（一定要想好搜素顺序）
qq_46126537的博客
10-14 523
排列数字 #include <bits/stdc++.h> using namespace std; typedef long long ll; const int N=10; int path[N]; //用来存方案 int st[N]; //用来检查哪一个数被用过 int n; void dfs(int u) { //表示深搜到最后了，即可以输出结果 if(u==n) { for(int i=0;i<n;i++) cout<
欧拉函数
qq_46126537的博客
12-04 517
φ(n)：表示1~n中与n互质的数的个数 证明的过程是基于容斥原理进行的 第一步：去掉1~n中所有p1、p2…pk的倍数 第二步：加上所有第一步去重了的倍数 欧拉函数 #include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; while (n--) { int a; cin >> a; int re
中国剩余定理
qq_46126537的博客
12-24 375
中国剩余定理 中国剩余定理给出了以下的一元线性同余方程组： 有解的判定条件，并用构造法给出了在有解情况下解的具体形式。 中国剩余定理说明：假设整数m1,m2, … ,mn两两互质，则对任意的整数：a1,a2, … ,an，方程组(S)有解，并且通解可以用如下方式构造得到： 设是整数m1,m2, … ,mn的乘积，并设是除了mi以外的n- 1个整数的乘积。 设的数论倒数( 为 模 意义下的逆元) 方程组(S)的通解形式为 在模M的意义下，方程组(S)只有一个解： 表达整数的奇怪方式 #include &
单调栈
qq_46126537的博客
10-04 343
单调栈（题目连接） 分析 根据样例： 3 4 2 7 5 若2存在，则前面的3 4永远不可能作为答案输出，所以在栈中删掉即可 基于这种思想，即可在栈中得到单调上升的序列 代码 使用vis做栈 #include <bits/stdc++.h> using namespace std; typedef long long ll; stack<int> vis; int main() { int n; scanf("%d", &n); while (n--)
大等于n的最小完全平方数 及 二分总结
qq_46126537的博客
10-04 309
问题描述 输出大等于n的最小的完全平方数。 若一个数能表示成某个自然数的平方的形式，则称这个数为完全平方数 Tips：注意数据范围 输入格式 一个整数n 输出格式 大等于n的最小的完全平方数 代码 #include <bits/stdc++.h> using namespace std; typedef long long ll; int main() { ll n; cin >> n; if (n <= 0) cout <<
Treap数据结构详解：操作与应用
"Treap是一种平衡二叉查找树，结合了树和堆的特性，用于高效的数据操作，如插入和删除。它通过随机化的优先级保证平衡性，从而实现平均情况下的优秀性能。本文深入探讨了Treap的原理、构建方法、特点以及在信息学...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值