[模板] 普通平衡树

最新推荐文章于 2024-09-26 16:50:25 发布
最新推荐文章于 2024-09-26 16:50:25 发布
阅读量95 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/Neworld2002/p/10034158.html
版权

传送门

您需要一种数据结构：

  • 插入一个数\(x\)
  • 删除一个数\(x\)
  • 查询\(x\)这个数在所有数中的排名
  • 查询排名为\(x\)的数
  • 求\(x\)这个数的前驱（前驱定义为小于\(x\)的最大数）‘
  • 求\(x\)这个数的后继（后继定义为大于\(x\)的最小数）

平衡树

Splay

#include <cstdio>
#include <cstring>
#include <algorithm>
#define MAXN 1000005
#define lson ch[rt][0]
#define rson ch[rt][1]
#define INF 2147483647

struct IO {
    char ibuf[1 << 25],*s;
    IO() {
        fread(s = ibuf,1,1<<25,stdin);
    }
    inline int read() {
        int num = 0,f = 1;
        while(*s<'0'||*s>'9') if((*s++)=='-') f = -1;
        while( *s>='0' && *s<='9' ) num = num*10 + (*s++) - 48;
        return num*f;
    }
}ip;
#define read ip.read

int size[MAXN],fa[MAXN],ch[MAXN][2],count[MAXN],val[MAXN];
int root,tot;
int N,opt,x;

inline void maintain(int rt) {
    size[rt] = size[lson] + size[rson] + count[rt];
}

inline void rotate(int rt) {
    int y = fa[rt]; int z = fa[fa[rt]];
    bool pos = (ch[y][1]==rt); int son = ch[rt][pos^1];
    fa[rt] = z; if(z) ch[z][ch[z][1]==y] = rt;
    ch[y][pos] = son; if(son) fa[son] = y;
    fa[y] = rt; ch[rt][pos^1] = y;
    maintain(y); maintain(rt);
}

inline void Splay(int rt,int goal) {
    for(int y=fa[rt],z=fa[fa[rt]];y!=goal;y=fa[rt],z=fa[fa[rt]]) {
        if(z!=goal) ((ch[y][1]==rt)==(ch[z][1]==y)) ? rotate(y) : rotate(rt);
        rotate(rt);
    }
    root = rt;
}

inline void insert(int num) {
    int rt = root,y = 0;
    while(rt&&val[rt]!=num) y = rt, rt = ch[rt][num>val[rt]];
    if(rt) count[rt] ++;
    else {
        val[rt = ++tot] = num; size[rt] = count[rt] = 1;
        ch[rt][0] = ch[rt][1] = 0; fa[rt] = y;
        if(y) ch[y][num>val[y]] = rt;
    }
    Splay(rt,0);
}

inline void find(int num) {
    int rt = root; if(!rt) return;
    while(val[rt]!=num&&ch[rt][num>val[rt]]) rt = ch[rt][num>val[rt]];
    Splay(rt,0);
}

inline int Next(int num,bool flag) {
    find(num); if((val[root]>num&&flag)||(val[root]<num&&!flag)) return root;
    int rt = ch[root][flag]; while(ch[rt][flag^1]) rt = ch[rt][flag^1];
    return rt;
}

inline int Kth(int k) {
    int rt = root;
    while(true) {
        if(k<=size[lson]) rt = lson;
        else if(k>size[lson]+count[rt]) k -= size[lson]+count[rt], rt = rson;
        else return rt;
    }
}

inline void Del(int num) {
    int _last = Next(num,0); int _next = Next(num,1);
    Splay(_last,0); Splay(_next,_last);
    int del = ch[_next][0];
    if(count[del]>1) count[del] --,Splay(del,0);
    else ch[_next][0] = 0,Splay(_next,0);
}

int main() {

    N = read(); insert(INF); insert(-INF);
    for(int i=1;i<=N;++i) {
        opt = read(); x = read();
        if(opt==1) insert(x);
        else if(opt==2) Del(x);
        else if(opt==3) {find(x);printf("%d\n",size[ch[root][0]]);}//需要把-INF扣掉
        else if(opt==4) printf("%d\n",val[Kth(x+1)]);//-INF
        else if(opt==5) printf("%d\n",val[Next(x,0)]);
        else printf("%d\n",val[Next(x,1)]);
    }

    return 0;
}

线段树

  • 不会
  • 先离散化一下，因为数字太大了
  • 线段树维护区间内有多少个数
  • 离散化的新编号就是线段树对应区间的位置

插入ins()

  • 计算\(x\)离散化后的对应编号\(num\)
  • 单点修改区间\([num,num]\)，+1即可

删除del()

  • 计算\(x\)离散化后的对应编号\(num\)
  • 单点修改区间\([num,num]\)，-1即可

查询排名clac_rk()

  • 计算\(x\)离散化后的对应编号\(num\)
  • 查询区间\([1,num]\)的和，+1即是答案，因为\(x\)前面有若干个数，若干个数+1就\(x\)的排名

查询对应排名的数find_rk()

  • 二分查找，判断\([1,mid]\)的和与给定排名的大小关系。

查前驱

  • find_rk(calc_rk(x)-1)

查后继

  • find_rk(calc_rk(x)+N+1)，其中\(N\)为\(x\)的数量

代码

#include <cstdio>
#include <cstring>
#include <algorithm>
#define MAXN 100005
#define lson (rt<<1)
#define rson (rt<<1|1)

int seg[MAXN<<2];
inline void pushup(int rt) {
    seg[rt] = seg[lson] + seg[rson];
}

void update(int C,int L,int rt,int l,int r) {
    if(l==r&&l==L) {
        seg[rt] += C;
        return;
    }
    int mid = (l+r)>>1;
    if(L<=mid) update(C,L,lson,l,mid);
    else update(C,L,rson,mid+1,r);
    pushup(rt);
}

int query(int L,int R,int rt,int l,int r) {
    if(L>R) return 0;
    if(L<=l&&R>=r) return seg[rt];
    if(L>r||R<l) return 0;
    int mid = (l+r)>>1,ans = 0;
    if(L<=mid) ans += query(L,R,lson,l,mid);
    if(R>mid) ans += query(L,R,rson,mid+1,r);
    return ans;
}

struct Discretization {
    int temp[MAXN],num[MAXN],tot,cnt;
    void reset() {
        tot = 0;
        cnt = 0;
    }
    int get_num(int u) {
        int l = 1, r = tot;
        while(l<r) {
            int mid = (l+r+1)>>1;
            if(num[mid]>u) r = mid - 1;
            else l = mid;
        }
        return l;
    }
    int find(int rk) {
        int l = 1,r = tot;
        while(l<r) {
            int mid = (l+r)>>1;
            int x = query(1,mid,1,1,tot);
            if(x>=rk) r = mid;
            else l = mid + 1;
        }
        return num[l];
    }
    void add(int u) {
        temp[++cnt] = u;
    }
    void unique() {
        for(int i=1;i<=cnt;++i) {
            if(temp[i]!=temp[i+1]) num[++tot] = temp[i];
        }
    }
}D;

struct Opt {
    int opt,num;
}G[MAXN];

int N;

int main() {

    D.reset();

    scanf("%d",&N);
    for(int i=1;i<=N;++i) {
        scanf("%d%d",&G[i].opt,&G[i].num);
        if(G[i].opt!=4) D.add(G[i].num);
    }

    std::sort(D.temp+1,D.temp+1+D.cnt);
    D.unique();

    std::memset(seg,0,sizeof(seg));
    for(int i=1;i<=N;++i) {
        if(G[i].opt==1) update(1,D.get_num(G[i].num),1,1,D.tot);
        else if(G[i].opt==2) update(-1,D.get_num(G[i].num),1,1,D.tot);
        else if(G[i].opt==3) printf("%d\n",query(1,D.get_num(G[i].num)-1,1,1,D.tot) + 1);
        else if(G[i].opt==4) printf("%d\n",D.find(G[i].num));
        else if(G[i].opt==5) {
            int rk = query(1,D.get_num(G[i].num)-1,1,1,D.tot);
            printf("%d\n",D.find(rk));
        }
        else if(G[i].opt==6) {
            int x = D.get_num(G[i].num);
            int rk = query(1,x-1,1,1,D.tot) + query(x,x,1,1,D.tot) + 1;
            printf("%d\n",D.find(rk));
        }
    }

    return 0;
}

树状数组

代码思路和线段树差不多，除了给定排名查数有个骚操作，先贴代码。

#include <cstdio>
#include <cstring>
#include <algorithm>
#define MAXN 100005
#define lowbit(x) (x&(-x))

struct disc {
    int temp[MAXN],a[MAXN],cnt,tot;
    disc() : cnt(0),tot(0) {}
    void add(int x) {
        temp[++tot] = x;
    }
    void unique() {
        std::sort(temp+1,temp+1+tot);
        for(int i=1;i<=tot;++i) 
            if(temp[i]!=temp[i-1]) a[++cnt] = temp[i];
    }
    int number(int x) {
        int l = 1,r = cnt;
        while(l<r) {
            int mid = (l+r+1)>>1;
            if(a[mid]>x) r = mid - 1;
            else l = mid;
        }
        return l;
    }
}d;

struct q {
    int opt,x;
}Q[MAXN];

int C[MAXN];

inline int query(int x) {
    int ans = 0;
    for(;x>=1;x-=lowbit(x)) ans += C[x];
    return ans;
}

inline void update(int x,int u) {
    for(;x<=d.cnt;x+=lowbit(x)) C[x] += u;
}

inline int work(int rk) {
    int ans = 0,count = 0;
    for(int i=1<<17;i>=1;i>>=1) {
        ans += i;
        if(ans>d.cnt||C[ans]+count>=rk) ans -= i;
        else count += C[ans];
    }
    return ans + 1;
}

int N;

int main() {

    scanf("%d",&N);
    for(int i=1;i<=N;++i) {
        scanf("%d%d",&Q[i].opt,&Q[i].x);
        if(Q[i].opt!=4) d.add(Q[i].x);
    }
    d.unique();

    for(int i=1;i<=N;++i) {
        if(Q[i].opt==1) update(d.number(Q[i].x),1);
        else if(Q[i].opt==2) update(d.number(Q[i].x),-1);
        else if(Q[i].opt==3) printf("%d\n",query(d.number(Q[i].x)-1) + 1);
        else if(Q[i].opt==4) printf("%d\n",d.a[work(Q[i].x)]);
        else if(Q[i].opt==5) printf("%d\n",d.a[work(query(d.number(Q[i].x)-1))]);
        else printf("%d\n",d.a[work(query(d.number(Q[i].x))+1)]);
    }

    return 0;
}

转载于:https://www.cnblogs.com/Neworld2002/p/10034158.html

anxie6422
关注
普通平衡树模板
M.L.B
01-12 359
直接上代码 内容都在代码里 //不正经的splay注释版代码 //bzoj 3224 普通平衡树 /*平衡树的本质其实是二叉搜索树，所以很多操作是基于二叉搜索树的操作。 splay的本质是rotate，旋转其实只是为了保证二叉搜索树的平衡性。 所有的操作一定都满足二叉搜索树的性质，所有改变父子关系的操作一定要update。 关键是理解rotate，splay的原理以及每一个操作
P3369 【模板】普通平衡树（splay 算法）
zhi6fui的博客
03-28 811
比如：x右旋，x的右儿子为y,这时原本的x的右儿子就要当y的左儿子。第一行为 n，表示操作的个数,下面 n 行每行有两个数 opt 和 x，opt 表示操作的序号（1≤opt≤6）我们找到它的前驱和后继，再进行把删除的点移到其后继的左儿子上，再进行删除操作。我们自己构造平衡二叉树，左儿子节点小于父节点，右儿子的全部节点大于父节点。而且x为y的左儿子，x的任意一个儿子一定小于其x的父节点。当直线型时，先旋转它的父节点，在旋转它自己本身。在遍历它的左儿子的右儿子。右旋时：x的右儿子当作y的左儿子。
P6136 【模板】普通平衡树（数据加强版）题解 pb_ds 模版
达瓦里希，这里禁喵。
04-01 1396
pb_ds真香~~~
洛谷 P6136：【模板】普通平衡树（数据加强版） ← Splay树模板题
hnjzsyjyj的专栏
05-07 423
● Treap 树解决平衡的办法是给每个结点加上一个随机的优先级，实现概率上的平衡。Splay 树直接用旋转调整树的形态，通过旋转改善树的平衡性。计算量小，效果好。 ● Splay 树的旋转主要分为“单旋”和“双旋”。
洛谷 P3369 【模板】普通平衡树--平板电视stl大法
liamaking的博客
12-14 819
题目描述 您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作： 插入 xx 数 删除 xx 数(若有多个相同的数，因只删除一个) 查询 xx 数的排名(排名定义为比当前数小的数的个数 +1+1 ) 查询排名为 xx 的数 求 xx 的前驱(前驱定义为小于 xx，且最大的数) 求 xx 的后继(后继定义为大于 xx，且最小的数) 输入格式 第一行为 nn，表示操作的个数,下面 nn 行每行有两个数 \text{opt}opt 和 xx，\text{opt}opt 表示操作的序号( 1
P3369 【模板】普通平衡树 Treap树堆学习笔记
马角的逆袭的博客
11-17 836
文章目录Treap = Tree + Heap (树堆 = 树 + 堆)1. 例题1 洛谷P3369 【模板】普通平衡树1. 结构体定义如下2. 向上更新`以u为根的树的节点个数`3. 旋转操作 route4. 插入操作 insert5. 删除操作 del6. 查询排名rand_x7. 查询 K 小值 kth8. 求key的前驱 get_pre9. 求key的后继 get_suf完整代码扩展应用1. 线段树套平衡树，求区间前驱后继排名(就是线段树的每个节点都是一个平衡树)2. 伸展树, 区间反转分割3. 双
P3369 【模板】普通平衡树
2302_78855882的博客
08-22 412
【代码】P3369 【模板】普通平衡树。
洛谷P3369 【模板】普通平衡树（STL做法：vector&multiset）
小哈里的博客
09-23 820
problem solution1 - AC vector可以AC。lower_bound找第一个大于等于x的，upper_bound找第一个大于x的。 #include<bits/stdc++.h> using namespace std; int main(){ ios::sync_with_stdio(0), cin.tie(0), cout.tie(0); int T; cin>>T; vector<int>a; while(T--){ int
普通平衡树　treap
zeus00的博客
11-26 300
平衡树模板题http://codevs.cn/problem/4543/Description写一种数据结构，来维护一些数，其中需要提供以下操作： 1. 插入x数 2. 删除x数(若有多个相同的数，因只删除一个) 3. 查询x数的排名(若有多个相同的数，因输出最小的排名) 4. 查询排名为x的数 5. 求x的前驱(前驱定义为小于x，且最大的数) 6. 求x的后继(后继定义为大于x，且最小
P3369 【模板】普通平衡树 [权值线段树做法]
Ajwallet
05-30 656
权值线段树继续瞎搞
洛谷P3369【模板】普通平衡树
L_Y_T020321的博客
07-21 505
本蒟蒻最近刚刚学会平衡树，特来写篇博客以加深印象。 （我的意思是若写的不好望各位奆佬多多包含！） 题目描述 您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作： 插入 x 数 删除 x 数(若有多个相同的数，因只删除一个) 查询 x 数的排名(排名定义为比当前数小的数的个数 +1 。若有多个相同的数，因输出最小的排名) 查询排名为 x 的数 求 x 的前驱(...
P3369 【模板】普通平衡树 （权值线段树解法）
矮纸斜行闲作草
02-11 225
题目链接 可以用权值线段树维护一个[-inf,inf]大小的桶 。 插入删除就是点修改 求v的排名：求出区间[-inf,v-1]里面数的个数再加1 求排名为k的数：权值线段树的基本操作 求v的前驱：先求出[-inf,v]区间数的个数，再减去桶里面v的个数得到的就是前驱节点的排名 。然后按排名求出前驱即可 求v的后继：先求出[-inf,v]区间数的个数，再+1就得到后继的排名，再按排名求出后继。 #include<bits/stdc++.h> using namespace std; #def
平衡树 模板
A2484337545的博客
11-16 475
例题P3369 【模板】普通平衡树 概念： 平衡树是二叉搜索树和堆合并构成的数据结构，它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 性质：对于每一个节点，满足它大于左儿子里的每一个节点，小于右儿子的每一个节点,即树的中序遍历为有序序列 对于一个平衡树，它可以支持的操作有 1:插入一个值 2:删除一个值 3:查询一个 xxx 的排名 4:查询排名为 xxx 的值 5:查询严格小于 xxx 的最大值 6:查询严格大于 xxx 的最小值 时间复杂度:不论哪一种
P6136 【模板】普通平衡树（数据加强版）
_Griefs
08-24 146
题目如同洛谷普通平衡树。 数据加强， 题解rank1是 WBLT 写的，本来想学一下，但是我这个 SBT 跑的还是蛮快的，就不学了。 目前洛谷rank3，可是rank1，rank2都是SBT 写的。。为啥比我的要快。。 #include<iostream> #include<cstdlib> #include<cstdio> #include<algori...
FHQ-Treap P3369 【模板】普通平衡树
xuxiaobo1234的博客
09-30 606
Treap是 二叉搜索树（BST）和二叉堆（Heap）的结合。二叉搜索树支持Treap的所有一般功能，例如查排名，查第k大，前驱，后继，删除，插入。它的特点是左子树小于等于根，右子树大于等于根。但是它的复杂度依赖于树的高度，而树的高度很容易被数据卡成链。 Heap是一种完全二叉树，它的树高为log(n)。一般有小根堆和大根堆。我们以小根堆为例，它的特点是根节点小于等于子节点。 其实到这里我们会发现两种树的性质是矛盾的，BST要求左儿子小于等于根，右儿子大于等于根，Heap要求根既小于等于左儿子，又小于等于右
反光柱定位算法-经典三边定位最小二乘法-直接法
最新发布
苏凯的博客
09-26 167
（二）计算姿态方式是我们已经通过最小二乘得到了小车在地图中的位置或者是雷达在地图中的位置，又因为我们知道雷达与小车的安装坐标，所以可以求解出一其中一个坐标的知量，通过小车在地图中坐标与雷达在地图中坐标可以得到一条向量，通过计算向量在地图中的角度就能得到姿态了。与最小二乘三边测量法相比，新算法在动态调整、优化过程和鲁棒性方面优势明显，尤其适合动态环境下的机器人定位，而最小二乘三边测量法在动态复杂环境中精度相对较低。（一）与（二）的区别主要是在计算姿态上的算法不同。经典三边定位最小二乘法 (法一)
每日算法2（翻转链表）
wdnmdfky的博客
09-25 218
接着进入循环，我们选不探讨循环条件，先研究循环语句，n2的next要存储n1，就是为了使最后的链表的next的空，n1=n2,n2=n3,if(n3)n3=n3->， n1是整个链表，n2=n3是为了指向后面的元素，在将后面的元素插入到n1前面，然后再让n1是指向头节点，最后5就是新的头节点。先来讲下最简单的算法，创建一个新链表，将原链表的元素挨个头插到新链表上，就实现了顺序表的逆转，这里就不示例代码了，在之前的链表有提及。让n1指向空，n2指向头，n3指向head->next。
leetcode331. 验证二叉树的前序序列化
Turboyiyi的博客
09-25 378
验证二叉树的前序序列化
数据结构讲解二叉树 【一】
2401_85388078的博客
09-25 1179
在数据结构中，二叉树作为步入实现复杂结构的门栏，为后续的图，排序衔接紧密，因此我将详细讲解二叉树，初定分为三至五篇文章讲解。文章干货满满，还请您细细品读，如果您觉得作者写得不错，抑或对您有所帮助，不妨给俺点个免费的赞和玩玩呢？关注作者不迷路，后续将有更多原创内容更新哟点点点点点点点点点点点点。
红黑树：平衡搜索树的优化利器与应用场景
相比于普通的二叉搜索树，红黑树提供了更稳定的查找、插入和删除操作时间复杂度，尤其是在最坏情况下，这些操作的时间复杂度都能保证在O(log n)级别。 红黑树与AVL树类似，它们都是自平衡的数据结构，旨在避免极端...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值