Treap树 ← 洛谷P3369、AcWing253

已于 2024-05-06 16:01:42 修改
阅读量666 收藏 8
点赞数 12
分类专栏： 信息学竞赛 # Treap等高阶结构 文章标签： Treap
于 2024-05-06 15:54:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hnjzsyjyj/article/details/138482439
版权

【题目来源】
https://www.luogu.com.cn/problem/P3369
https://www.acwing.com/problem/content/255/

【题目描述】
您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作：
1. 插入数值 x。
2. 删除数值 x(若有多个相同的数，应只删除一个)。
3. 查询数值 x 的排名(若有多个相同的数，应输出最小的排名)。
4. 查询排名为 x 的数值。
5. 求数值 x 的前驱(前驱定义为小于 x 的最大的数)。
6. 求数值 x 的后继(后继定义为大于 x 的最小的数)。
注意： 数据保证查询的结果一定存在。

【输入格式】
第一行为 n，表示操作的个数。
接下来 n 行每行有两个数 opt 和 x，opt 表示操作的序号(1≤opt≤6)。

【输出格式】
对于操作 3,4,5,6 每行输出一个数，表示对应答案。

【数据范围】
1≤n≤100000，所有数均在 −10^7 到 10^7 内。

【输入样例】
10
1 106465
4 1
1 317721
1 460929
1 644985
1 84185
1 89851
6 81968
1 492737
5 493598

【输出样例】
106465
84185
492737

【算法分析】
● Treap 树是一种原理比较简单的 BST。Treap=Tree+Heap，即 Treap 是树和堆（大根堆或小根堆）的结合，通常翻译成树堆。
● Treap 树的操作基于“键值 val + 优先级 pri”。Treap 树的每个结点包含两个信息 (val, pri)，对于 val，它是一个 BST（二叉查找树），对于 pri，它是一个堆（大根堆或小根堆）。注意这条性质与笛卡尔树的异同。
● Treap 树的核心思想就是利用优先级维护二叉树的平衡性。
● 针对 Treap 树，由于每个结点的（val，pri）可看作结点在平面上的坐标，故若每个结点的键值 val，优先级 pri 已经事先确定且不同，那么建立的 Treap 树的形态是唯一的，与结点的插入顺序没有关系。Treap 树中结点的键值 val 确定了结点在 Treap 树中的横向位置，优先级 pri 确定了结点在 Treap 树中的纵向位置。
给定键值｛a,b,c,d,e,f,g｝，优先级｛6,5,2,7,3,4,1｝，构建的 Treap 树如下图所示：

● 需要注意，如果预先知道所有结点的键值 val，那么在构建 Treap 树时，先对所有的键值 val 进行递增排序，然后从键值 val 最小的结点开始，从左至右逐个向树上添加结点，并依据优先级（已知或随机）在纵向上调整形态。此种情形下，构建的 Treap 树就是笛卡尔树。建树的时间复杂度为 O(n)。
而在一般情况下，并不能预先知道结点的键值 val 和优先级 pri，做法是为读入的每个新键值 val 分配一个随机的优先级，在插入树中时动态调整树的结构，使它仍然是一棵 Treap 树。建树的时间复杂度为 O(log_2n)。
● 动态调整 Treap 树的结构，有两种方法：旋转法、FHQ 法。旋转法是经典方法，FHQ 法是近几年开始流行的新技术。FHQ 法编码简单，且能用于区间翻转、移动、持久化场合。 

【算法代码】

#include <bits/stdc++.h>
using namespace std;

const int maxn=1e5+5;
const int inf=0x3f3f3f3f;
int root,idx;

struct node {
    int le,ri;
    int val,pri;
    int cnt,size;
} tr[maxn];

void pushup(int p) { //update size
    tr[p].size=tr[tr[p].le].size+tr[tr[p].ri].size+tr[p].cnt;
}

int get_node(int val) { //build node
    tr[++idx].val=val;
    tr[idx].pri=rand();
    tr[idx].cnt=tr[idx].size=1;
    return idx;
}

void zig(int &p) { //rotate to right
    int q=tr[p].le;
    tr[p].le=tr[q].ri;
    tr[q].ri=p;
    p=q;
    pushup(tr[p].ri);
    pushup(p);
}

void zag(int &p) { //rotate to left
    int q=tr[p].ri;
    tr[p].ri=tr[q].le;
    tr[q].le=p;
    p=q;
    pushup(tr[p].le);
    pushup(p);
}

void build() {
    get_node(-inf);
    get_node(inf);
    root=1;
    tr[1].ri=2;
    pushup(root);
    if(tr[1].pri<tr[2].pri) zag(root);
}

void insert(int &p,int val) {
    if(!p) p=get_node(val);
    else if(tr[p].val==val) tr[p].cnt++;
    else if(tr[p].val>val) {
        insert(tr[p].le,val);
        if(tr[tr[p].le].pri>tr[p].pri) zig(p);
    } else {
        insert(tr[p].ri,val);
        if(tr[tr[p].ri].pri>tr[p].pri) zag(p);
    }
    pushup(p);
}

void erase(int &p,int val) {
    if(!p) return;
    if(tr[p].val==val) {
        if(tr[p].cnt>1) tr[p].cnt--;
        else if(tr[p].le || tr[p].ri) {
            if(!tr[p].ri || tr[tr[p].le].pri>tr[tr[p].ri].pri) {
                zig(p);
                erase(tr[p].ri,val);
            } else {
                zag(p);
                erase(tr[p].le,val);
            }
        } 
        else p=0;
    } 
    else if(tr[p].val>val) erase(tr[p].le,val);
    else erase(tr[p].ri,val);
    pushup(p);
}

int get_rank_by_val(int p,int val) {
    if(!p) return 0;
    if(tr[p].val==val) return tr[tr[p].le].size+1;
    if(tr[p].val>val) return get_rank_by_val(tr[p].le,val);
    return tr[tr[p].le].size+tr[p].cnt+get_rank_by_val(tr[p].ri,val);
}

int get_val_by_rank(int p,int rank) {
    if(!p) return 0;
    if(tr[tr[p].le].size>=rank) return get_val_by_rank(tr[p].le,rank);
    if(tr[tr[p].le].size+tr[p].cnt>=rank) return tr[p].val;
    return get_val_by_rank(tr[p].ri,rank-tr[tr[p].le].size-tr[p].cnt);
}

int get_prev(int p,int val) {
    if(!p) return -inf;
    if(tr[p].val>=val) return get_prev(tr[p].le,val);
    return max(tr[p].val,get_prev(tr[p].ri,val));
}

int get_next(int p,int val) {
    if(!p) return inf;
    if(tr[p].val<=val) return get_next(tr[p].ri,val);
    return min(tr[p].val,get_next(tr[p].le,val));
}

int main() {
    build();
    int n;
    scanf("%d",&n);
    while(n--) {
        int op,x;
        scanf("%d %d",&op,&x);
        if(op==1) insert(root,x);
        else if(op==2) erase(root,x);
        else if(op==3) printf("%d\n",get_rank_by_val(root,x)-1);
        else if(op==4) printf("%d\n",get_val_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;
}

/*
in:
10
1 106465
4 1
1 317721
1 460929
1 644985
1 84185
1 89851
6 81968
1 492737
5 493598

out:
106465
84185
492737
*/


本题利用替罪羊树的代码解法如下：

#include<bits/stdc++.h>
using namespace std;

const int maxn=1e5+5;
const double alpha=0.7;

struct node {
    int le,ri;
    int cnt,val,size;
} sgt[maxn];

int n,m;
int cnt=1;

/*
tp 表示子树中结点下标组成的线性序列
tn 表示子树中结点个数组成的线性序列
tv 表示子树中结点权值组成的线性序列
*/
vector<int> tp,tn,tv;

bool exist(int x) {
    return !(sgt[x].le==0 && sgt[x].ri==0 && sgt[x].cnt==0);
}

int flatten(int x) {
    if(exist(sgt[x].le)) flatten(sgt[x].le);
    int id=tp.size();
    if(sgt[x].cnt) {
        tp.push_back(x);
        tn.push_back(sgt[x].cnt);
        tv.push_back(sgt[x].val);
    }
    if(exist(sgt[x].ri)) flatten(sgt[x].ri);
    return id;
}

void rebuild(int x,int le,int ri) {
    int mid=(le+ri)/2;
    int sizel=0,sizer=0;
    if(le<mid) {
        sgt[x].le=tp[(le+mid-1)/2];
        rebuild(sgt[x].le,le,mid-1);
        sizel=sgt[sgt[x].le].size;
    } else sgt[x].le=0;
    if(ri>mid) {
        sgt[x].ri=tp[(mid+1+ri)/2];
        rebuild(sgt[x].ri,mid+1,ri);
        sizer=sgt[sgt[x].ri].size;
    } else sgt[x].ri=0;
    sgt[x].cnt=tn[mid];
    sgt[x].val=tv[mid];
    sgt[x].size=sizel+sizer+sgt[x].cnt;
}

void restr(int x) {
    double val=max(sgt[sgt[x].le].size, sgt[sgt[x].ri].size)*1.0/sgt[x].size;
    if(val>alpha) {
        tp.clear();
        tn.clear();
        tv.clear();
        int id=flatten(x);
        swap(tp[id],tp[(tp.size()-1)/2]);
        rebuild(x,0,tp.size()-1);
    }
}

void insert(int x, int val) {
    if(!exist(x)) {
        sgt[x].cnt=1;
        sgt[x].val=val;
    } else if(val<sgt[x].val) {
        if(!exist(sgt[x].le)) sgt[x].le=++cnt;
        insert(sgt[x].le,val);
    } else if(val>sgt[x].val) {
        if (!exist(sgt[x].ri)) sgt[x].ri=++cnt;
        insert(sgt[x].ri,val);
    } else sgt[x].cnt++;
    sgt[x].size++;
    restr(x);
}

void del(int x, int val) {
    sgt[x].size--;
    if(val<sgt[x].val) del(sgt[x].le,val);
    else if (val>sgt[x].val) del(sgt[x].ri,val);
    else sgt[x].cnt--;
    restr(x);
}

int ord_pre(int x, int val) {
    if(val<sgt[x].val)
        return (exist(sgt[x].le)?ord_pre(sgt[x].le,val):0);
    else if(val>sgt[x].val)
        return sgt[sgt[x].le].size+sgt[x].cnt+(exist(sgt[x].ri)?ord_pre(sgt[x].ri,val):0);
    else
        return sgt[sgt[x].le].size;
}

int ord_nxt(int x, int val) {
    if(val>sgt[x].val)
        return ((exist(sgt[x].ri)?ord_nxt(sgt[x].ri,val):0));
    else if(val<sgt[x].val)
        return sgt[sgt[x].ri].size+sgt[x].cnt+(exist(sgt[x].le)?ord_nxt(sgt[x].le,val):0);
    else
        return sgt[sgt[x].ri].size;
}

int ord(int val) {
    return ord_pre(1,val)+1;
}

int find(int x, int rk) {
    if(rk<=sgt[sgt[x].le].size)
        return find(sgt[x].le, rk);
    else if(rk>sgt[sgt[x].le].size+sgt[x].cnt)
        return find(sgt[x].ri, rk-sgt[sgt[x].le].size-sgt[x].cnt);
    else
        return sgt[x].val;
}

int pre(int x) {
    int rk=ord_pre(1,x);
    return find(1,rk);
}

int nxt(int x) {
    int rk=ord_nxt(1,x);
    return find(1,sgt[1].size-rk+1);
}

int main() {
    int opt,x;
    scanf("%d",&n);
    for(int i=1; i<=n; i++) {
        scanf("%d%d",&opt,&x);
        if(opt==1) insert(1,x);
        else if(opt==2) del(1,x);
        else if(opt==3) printf("%d\n",ord(x));
        else if(opt==4) printf("%d\n",find(1,x));
        else if(opt==5) printf("%d\n",pre(x));
        else printf("%d\n",nxt(x));
    }
    return 0;
}


/*
in:
10
1 106465
4 1
1 317721
1 460929
1 644985
1 84185
1 89851
6 81968
1 492737
5 493598

out:
106465
84185
492737
*/




【参考文献】
https://blog.csdn.net/hnjzsyjyj/article/details/120380473
https://www.acwing.com/solution/content/153478/






 

hnjzsyjyj
关注
  • 12
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
FHQ-Treap 树 ← 洛谷P3369、AcWing253
hnjzsyjyj的专栏
09-19 247
●FHQ−Treap，也称非旋 Treap，由范浩强提出。顾名思义，FHQ−Treap 就是不需要通过旋转，而是通过分裂（split）与合并（merge）维护的 Treap。FHQ−Treap 与 Treap 的另外一个区别是 FHQ−Treap 可持久化。​​​​​​​ ● FHQ-Treap 的高明之处在于所有的操作都只用到了分裂（split）与合并（merge）这两个基本操作。
替罪羊树 ← 洛谷P3369、AcWing253
hnjzsyjyj的专栏
01-11 390
替罪羊树（Scapegoat Tree），作为最简单的一种维护二叉树平衡的BST，采用简单而暴力的“摧毁、重建”方法维护二叉树的平衡： 1.若二叉树的某棵子树不平衡了，先求得这棵子树的中序遍历序列，然后再删除这棵子树。谓之“摧毁”。 2.以第1步得到的中序遍历序列的中间元素为根，构建一棵平衡的子树。谓之“重建”。
AcWing算法提高课笔记
m0_72747430的博客
07-22 2092
Level2 1.动态规划——从集合角度考虑DP问题 1.1 数字三角形模型 1.1.1摘花生 Hello Kitty想摘点花生送给她喜欢的米老鼠。 她来到一片有网格状道路的矩形花生地(如下图)，从西北角进去，东南角出来。 地里每个道路的交叉点上都有种着一株花生苗，上面有若干颗花生，经过一株花生苗就能摘走该它上面所有的花生。 Hello Kitty只能向东或向南走，不能向西或向北走。 问Hello Kitty最多能够摘到多少颗花生。 输入格式 第一行是一个整数T，代表一共有多少
省选＋NOI 第五部分 高级数据结构
青少年趣味编程
03-17 876
左偏树 【AgOHの数据结构】左偏树 【AgOHの数据结构】左偏树_哔哩哔哩_bilibili CSU-ICPC集训课程 启发式合并和左偏树 CSU-ICPC集训课程 启发式合并和左偏树_哔哩哔哩_bilibili 【模板】左偏树 【模板】左偏树 - ShuraEye - 博客园 算法详解——左偏树 算法详解——左偏树_Canopus-CSDN博客_左偏树 【左偏树 】【可并堆】 【左偏树 】【可并堆】 - Mathison 的博客 - 洛谷博客 平衡树splay
高级数据结构（算法提高课）
m0_74911187的博客
09-02 209
题目链接：https://www.luogu.com.cn/problem/P1455这题是并查集与01背包的一个结合，我们可以将搭配在一起的云朵合并，并且将属于一个集合的云朵的价格和价值都加在该集合的根节点中，在进行一次01背包就可以了得到给定金钱能买到的最大价值了代码如下： 2，程序自动分析 题目链接：https://www.acwing.com/problem/content/239/这题运用了离散化和并查集，因为数据范围很大，所以我们要先离散化将数据映射到一个小区间上，然后用并查集动态维护，对
千里之行始于足下梦开始的地方——A+B problem C++史上最详解，氵题一道，109 种解法！（附加多种语法的代码）
AcWing_Conan15的博客
05-02 847
A+B——C++基础例题，但是有许许多多奇奇怪怪的解法（） 请认准@AcWing_Conan15为原创作者！
CSP-S —— NOIP 2021 日记
qq_42852687的博客
12-02 1012
from 2021.9.27 to 2021.11.29 9.27 25天 时隔很久又回到了洛谷blog，感觉日记一类的就不要上csdn干扰别人的学术探讨了吧hh（我的csdn博客阅读量最高的竟然是学习计划和目录！！） 今天是赶完所有图论板子的纪念性的一天，决定9.30就要上树了，考前可能就不怎么玩图论了吧，拓扑的博客就差一点，预计29肯定上新了，tarjan是真的好麻烦哎，想想我的第一个博客就是tarjan，干了3个三晚，现在又耗了一下午整理，好多定义算法二刷感觉真的不一样（感觉再给我一年我肯定爆棚的宁
基础数据结构
qym2008 的博客
06-05 225
rt，数据结构模板，主要是用来保存，需要的也可以拿去用αωα ST表（区间最大值模板）： #include<bits/stdc++.h> using namespace std; const int N=1e5*2+10,M=18; int w[N],f[N][M],n,m; void init() { for(int j=0;j<M;j++) for(int i=1;i+(1<<j)-1<=n;i++) if(!j) f[
自学算法竞赛笔记
fry_rice_at_pub的博客
05-13 653
思路2：DP 状态转移方程：a[x][y]+=max(a[x+1][y],a[x+1][y+1]) 备份数组+当前点下行方向数组。思路1：记忆化搜索+DFS，从下到上累加和可以重复使用。
Treap 树堆 和 Skip Lists
07-17
Treap树和跳表（Skip Lists）都是平衡树结构，它们用于维持有序数据集合，保证数据的快速检索、插入和删除操作。这两种数据结构与传统的AVL树、红黑树、B树或伸展树相比，其特点在于它们以一种随机的方式进行平衡，...
无旋treap/fhq-treap 模板 （附良心讲解 + 例题：洛谷P3369 普通平衡树）
shadiao.的博客
09-09 698
博文更新： 20190917 更新了一下merge和split函数的递归理解 定义： 无旋treap，就是不通过旋转的维护堆性质的treap，根本的原理还是 tree + heap。 与普通treap的不同之处： 大概就是可以可持久化。 然后区间操作的话，不知道有旋的行不行，用无旋的反正是比较好搞，区间操作举个例子就是让你把一段区间的数反过来等等。 现在听着可能区间操作什么的可能莫名...
洛谷 P2286 [HNOI2004]宠物收养场 (treap 树)
qq_38232157的博客
09-21 165
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,
FHQ-Treap P3369 【模板】普通平衡树
xuxiaobo1234的博客
09-30 602
Treap是 二叉搜索树（BST）和二叉堆（Heap）的结合。二叉搜索树支持Treap的所有一般功能，例如查排名，查第k大，前驱，后继，删除，插入。它的特点是左子树小于等于根，右子树大于等于根。但是它的复杂度依赖于树的高度，而树的高度很容易被数据卡成链。 Heap是一种完全二叉树，它的树高为log(n)。一般有小根堆和大根堆。我们以小根堆为例，它的特点是根节点小于等于子节点。 其实到这里我们会发现两种树的性质是矛盾的，BST要求左儿子小于等于根，右儿子大于等于根，Heap要求根既小于等于左儿子，又小于等于右
这是作者的API开发网站，采用Django开发框架.zip
最新发布
08-26
这是作者的API开发网站，采用Django开发框架.zip
VSCode 配置 C/C++ 环境详细教程
08-26
基于Windows、linux、macos三大平台教程
ant-design-vue-1.3.15.zip
08-26
基于 Ant Design 和 Vue 的企业级 UI 组件库
ant-design-vue-1.1.7.zip
08-26
基于 Ant Design 和 Vue 的企业级 UI 组件库
ant-design-5.19.3.zip
08-26
ant-design，一套企业级 UI 设计语言和 React 组件库 提炼自企业级中后台产品的交互语言和视觉风格 开箱即用的高质量 React 组件
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值