洛谷 P3380 模板 二逼平衡树 线段树套平衡树

于 2022-06-08 21:33:13 发布
阅读量170 收藏
点赞数
分类专栏： 数据结构 文章标签： 图论 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46975572/article/details/125192989
版权

洛谷 P3380 模板 二逼平衡树 线段树套平衡树

title

Code

#include <cstdio>
#include <cstdlib>

using namespace std;

const int N = 1800010, INF = 1000000000;

struct Treap {

	int l[N], r[N], d[N], siz[N], cnt[N], val[N];
	int tot, rt, ERR;



	int mk(int v) {
		val[++tot] = v;
		d[tot] = rand();
		siz[tot] = 1;
		cnt[tot] = 1;
		return tot;
	}

	int update(int x) {
		return siz[x] = siz[l[x]] + siz[r[x]] + cnt[x];
	}

	int leftRotate(int &x) {
		int tmp = r[x];
		r[x] = l[tmp];
		l[tmp] = x;
		x = tmp;
		update(l[x]);
		update(x);
		return x;
	}

	int rightRotate(int &x) {
		int tmp = l[x];
		l[x] = r[tmp];
		r[tmp] = x;
		x = tmp;
		update(r[x]);
		update(x);
		return x;
	}

	void insert(int &x, int v) {
		if (!x) {
			x = mk(v);
			return ;
		}
		if (v == val[x]) ++cnt[x];
		else {
			if (v < val[x]) {
				insert(l[x], v);
				if (d[x] < d[l[x]])
					rightRotate(x);
			} else {
				insert(r[x], v);
				if (d[x] < d[r[x]])
					leftRotate(x);
			}
		}
		update(x);
		return ;
	}

	void erase(int &x, int v) {
		if (!x) return ;
		if (v == val[x]) {
			if (cnt[x] > 1) --cnt[x], update(x);
			else if (!l[x] && !r[x]) x = 0;
			else {
				if (!r[x] || d[r[x]] < d[l[x]]) rightRotate(x), erase(r[x], v);
				else leftRotate(x), erase(l[x], v);
				update(x);
			}
			return ;
		}
		if (v < val[x]) erase(l[x], v);
		else erase(r[x], v);
		update(x);
		return ;
	}

	void del(int &x, int v) {
		if (!x) return ;
		if (v == val[x]) {
			cnt[x] = 1, update(x);
			if (!l[x] && !r[x]) x = 0;
			else {
				if (!r[x] || d[r[x]] < d[l[x]]) rightRotate(x), del(r[x], v);
				else leftRotate(x), del(l[x], v);
				update(x);
			}
			return ;
		}
		if (v < val[x]) del(l[x], v);
		else del(r[x], v);
		update(x);
		return ;
	}

	int rank(int rt, int v) {
		int x, ans = 0;
		for (x = rt; x;) {
			if (v < val[x]) x = l[x];
			else if (v > val[x]) ans += siz[l[x]] + cnt[x], x = r[x];
			else return ans + siz[l[x]] + 1;
		}
		return ans + 1;
	}

	int value(int rt, int v) {
		int x;
		for (x = rt; x;) {
			if (v <= siz[l[x]]) x = l[x];
			else if (v <= siz[l[x]] + cnt[x]) return val[x];
			else v -= siz[l[x]] + cnt[x], x = r[x];
		}
		return ERR;
	}

	bool find(int rt, int v) {
		int x;
		for (x = rt; x;) {
			if (v < val[x]) x = l[x];
			else if (v > val[x]) x = r[x];
			else return 1;
		}
		return 0;
	}

	int count(int rt, int v) {
		int x;
		for (x = rt; x;) {
			if (v < val[x]) x = l[x];
			else if (v > val[x]) x = r[x];
			else return cnt[x];
		}
		return ERR;
	}

	int pre(int rt, int v) {
		int res = ERR;
		for (int x = rt; x;)
			if (val[x] < v) res = val[x], x = r[x];
			else x = l[x];
		return res;
	}

	int nxt(int rt, int v) {
		int res = ERR;
		for (int x = rt; x;)
			if (val[x] > v) res = val[x], x = l[x];
			else x = r[x];
		return res;
	}

	int max(int rt) {
		int x;
		for (x = rt; r[x]; x = r[x]);
		return val[x];
	}

	int min(int rt) {
		int x;
		for (x = rt; l[x]; x = l[x]);
		return val[x];
	}

	int clear(int error) {
		rt = tot = 0;
		return ERR = error;
	}

	int error() {
		return ERR;
	}

	void insert(int x) {
		insert(rt, x);
		return ;
	}

	void erase(int x) {
		erase(rt, x);
		return ;
	}

	void del(int x) {
		del(rt, x);
		return ;
	}

	int rank(int v) {
		return rank(rt, v);
	}

	int value(int v) {
		return value(rt, v);
	}

	bool find(int v) {
		return find(rt, v);
	}

	int count(int v) {
		return count(rt, v);
	}

	int pre(int v) {
		return pre(rt, v);
	}

	int nxt(int v) {
		return nxt(rt, v);
	}

	int max() {
		return max(rt);
	}

	int min() {
		int x;
		for (x = rt; l[x]; x = l[x]);
		return min(rt);
	}

	int size(int rt) {
		return siz[rt];
	}

	bool empty(int rt) {
		return !siz[rt];
	}

	int size() {
		return siz[rt];
	}

	bool empty() {
		return !siz[rt];
	}



	/*
	int clear(int error)
		init the treap, the error result is error
		return the error

	int error()
		return the error

	int size()
		return how many numbers in treap

	bool empty()
		return true or false
		true : the treap is empty
		false : the treap isn't empty

	void insert(int x)
		insert x to the treap

	void erase(int x)
		delete x in the treap

	void del(int x)
		delete all x in the treap
		
	int rank(int v)
		return v 's rank

	int value(int v)
		return the vth small number

	bool find(int v)
		return true or false
		true : v is in the treap
		false : v isn't in the treap

	int count(int v)
		return how many v in the treap

	int pre(int v)
		return x
		x < v
		x is the biggest

	int nxt(int v)
		return x
		x > v
		x is the smallest

	int max()
		return x
		x is the biggest

	int min()
		return x
		x is the smallest
	*/
} ;



struct Segment {
	int rt[N], n, err, mn, mx;
	int* s;
	Treap t;

	int min(int x, int y) {
		return x < y ? x : y;
	}

	int max(int x, int y) {
		return x > y ? x : y;
	}

	void build(int k, int l, int r) {
		rt[k] = 0;
		for (int i = l; i <= r; ++i)
			t.insert(rt[k], s[i]);
		if (l < r) {
			int mid = (l + r) >> 1;
			build(k << 1, l, mid);
			build(k << 1 | 1, mid + 1, r);
		}
		return ;
	}

	int rank(int k, int l, int r, int x, int y, int v) {
		if (x <= l && r <= y)
			return t.rank(rt[k], v) - 1;
		int mid = (l + r) >> 1, res = 0;
		if (x <= mid)
			res += rank(k << 1, l, mid, x, y, v);
		if (y > mid)
			res += rank(k << 1 | 1, mid + 1, r, x, y, v);
		return res;
	}

	int value(int l, int r, int v) {
		int el, er, mid;
		for (el = mn, er = mx; el < er;) {
			mid = (el + er + 1) >> 1;
			if (rank(1, 1, n, l, r, mid) < v)
				el = mid;
			else
				er = mid - 1;
		}
		return el;
	}

	void modify(int k, int l, int r, int x, int v) {
		t.erase(rt[k], s[x]);
		t.insert(rt[k], v);
		mn = min(mn, v);
		mx = max(mx, v);
		if (l == r)
			return;
		int mid = (l + r) >> 1;
		if (x <= mid)
			modify(k << 1, l, mid, x, v);
		if (x > mid)
			modify(k << 1 | 1, mid + 1, r, x, v);
		return ;
	}

	int pre(int k, int l, int r, int x, int y, int v) {
		if (x <= l && r <= y)
			return t.pre(rt[k], v);
			
		int mid = (l + r) >> 1, ans = mn - 1;
		if (x <= mid) {
			int res = pre(k << 1, l, mid, x, y, v);
			if (res != err)
				ans = max(ans, res);
		}
		if (y > mid) {
			int res = pre(k << 1 | 1, mid + 1, r, x, y, v);
			if (res != err)
				ans = max(ans, res);
		}
		if (ans == mn - 1)
			return err;
		return ans;
	}

	int nxt(int k, int l, int r, int x, int y, int v) {
		if (x <= l && r <= y)
			return t.nxt(rt[k], v);
			
		int mid = (l + r) >> 1, ans = mx + 1;
		if (x <= mid) {
			int res = nxt(k << 1, l, mid, x, y, v);
			if (res != err)
				ans = min(ans, res);
		}
		if (y > mid) {
			int res = nxt(k << 1 | 1, mid + 1, r, x, y, v);
			if (res != err)
				ans = min(ans, res);
		}
		if (ans == mx + 1)
			return err;
		return ans;
	}

	void build(int n, int inf, int error, int* s) {
		mn = inf;
		mx = -inf;
		this->n = n;
		this->s = s;
		this->err = error;
		for (int i = 1; i <= n; ++i) {
			mn = min(mn, s[i]);
			mx = max(mx, s[i]);
		}
		t.clear(error);
		build(1, 1, n);
		return ;
	}

	int rank(int l, int r, int v) {
		return rank(1, 1, n, l, r, v) + 1;
	}

	void modify(int x, int v) {
		modify(1, 1, n, x, v);
		s[x] = v;
		return ;
	}

	int pre(int x, int y, int v) {
		return pre(1, 1, n, x, y, v);
	}

	int nxt(int x, int y, int v) {
		return nxt(1, 1, n, x, y, v);
	}
} ;

Segment tr;

int s[N];

int main() {
	int n, q, opt, l, r, v;
	scanf("%d %d", &n, &q);
	for (int i = 1; i <= n; ++i)
		scanf("%d", &s[i]);
	tr.build(n, INF, -1, s);
	for (; q; --q) {
		scanf("%d %d %d", &opt, &l, &r);
		if (opt == 3) 
			tr.modify(l, r);
		else {
			scanf("%d", &v);
			if (opt == 1) printf("%d\n", tr.rank(l, r, v));
			else if (opt == 2) printf("%d\n", tr.value(l, r, v));
			else if (opt == 4)  {
				int res = tr.pre(l, r, v);
				printf("%d\n", res == -1 ? -2147483647 : res);
			} else {
				int res = tr.nxt(l, r, v);
				printf("%d\n", res == -1 ? 2147483647 : res);
			}
		}
	}
	return 0;
}
SSL_MYD
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
洛谷P3380 二逼平衡树(树套树 / 整体二分)
Fau的博客
04-08 263
题目链接: 二逼平衡树 大致题意 读不懂就不要做这个题啦!!! 解题思路 思路一: 线段树套平衡树(既然题目都叫树套树了, 总得给个面子吧.) 首先我们观察五个操作, 我们发现他很像平衡树的题, 用平衡树维护序列有序即可. 但是由于每次查询是是对于区间的一次查询, 因此我们应当联想到采用线段树来维护询问区间, 然后再通过平衡树来解决问题. (这里稍微啰嗦几句, 一般的线段树套平衡树, 线段树的主要作用都是把查询的区间划分开. 因此线段树的内部是不维护信息的. 每次查询时, 我们通过线段树找到查询区间, 然后
BZOJ3196二逼平衡树——线段树套平衡树（treap）
weixin_33859504的博客
05-25 88
此为平衡树系列最后一道：二逼平衡树您需要写一种数据结构（可参考题目标题），来维护一个有序数列，其中需要提供以下操作： 1.查询k在区间内的排名2.查询区间内排名为k的值3.修改某一位值上的数值4.查询k在区间内的前驱(前驱定义为小于x，且最大的数)5.查询k在区间内的后继(后继定义为大于x，且最小的数) 输入 第一行两个数 n,m 表示长度为n的有...
BZOJ3196 Tyvj1730 二逼平衡树 【树套树】 【线段树套treap】
weixin_30372371的博客
05-25 119
BZOJ3196 Tyvj1730 二逼平衡树 Description 您需要写一种数据结构（可参考题目标题），来维护一个有序数列，其中需要提供以下操作： 1.查询k在区间内的排名 2.查询区间内排名为k的值 3.修改某一位值上的数值 4.查询k在区间内的前驱(前驱定义为小于x，且最大的数) 5.查询k在区间内的后继(后继定义为...
BZOJ3196 二逼平衡树 【线段树套平衡树】
weixin_30735745的博客
02-02 70
题目 您需要写一种数据结构（可参考题目标题），来维护一个有序数列，其中需要提供以下操作： 1.查询k在区间内的排名 2.查询区间内排名为k的值 3.修改某一位值上的数值 4.查询k在区间内的前驱(前驱定义为小于x，且最大的数) 5.查询k在区间内的后继(后继定义为大于x，且最小的数) 输入格式 第一行两个数 n,m 表示长度为n的有序序列和m个操作 第二行有n个数，表示有序序列 下面有m行，opt...
若干平衡树的C语言实现_C语言_平衡树_
09-29
若干平衡树的C语言实现，支持插入删除，数查排名，排名查数，查询前驱后继
AVL（平衡二叉检索）树模板（带template）
08-17
AVL树模板，支持操作如下 template struct BSTNode { T data; int h; BSTNode<T> * lchild, *rchild; }; template class AVLTree { public: AVLTree() :root(NULL),node_num(0) {} ~AVLTree() { Release...
AVLTree.zip_平衡树
09-14
二叉平衡树的删除，并可以调整平衡，还有平衡二叉树的插入操作
avl.rar_avl_平衡树
09-20
avl平衡树做的电话号码系统！！！可支持查询，修改，删除等操作
二轮平衡小车的平衡原理详解
02-08
二轮平衡小车的平衡原理详解 一、平衡小车的平衡原理 平衡小车是通过两个电机运动下实现小车不倒下直立行走的多功能智能小车。在外力的推拉下，小车依然保持不倒下。这个平衡小车实现的原理其实是在人们生活中的...
二逼平衡树（线段树套平衡树）
Old_Whig的博客
01-23 156
线段树套平衡树【题目】 先引入模板题：二逼平衡树。 本题要求实现一个数据结构，可以查询： 区间内x的排名/前驱/后继，排名为k的数；支持单点修改。【思考】 来源：二逼平衡树-线段树套无旋Treap 看到排名，可以联想到平衡树，但平衡树并不能直接实现区间操作。 看到区间修改，可以联想到线段树。 我们就把两个数据结构放在一起： 外层线段树，内层平衡树。 具体来说，在线段树的每个节点上(对每个区间)开...
bzoj3196 二逼平衡树 线段树套平衡树
yxr0105
05-08 755
题意：您需要写一种数据结构（可参考题目标题），来维护一个有序数列，其中需要提供以下操作： 1.查询k在区间内的排名 2.查询区间内排名为k的值 3.修改某一位值上的数值 4.查询k在区间内的前驱(前驱定义为小于x，且最大的数) 5.查询k在区间内的后继(后继定义为大于x，且最小的数) 题解：树套树，外层是一棵线段树，每个节点下有一棵平衡树(平衡树记录ls,rs，因此记录根节点就可以遍历整
二逼平横树——线段树套平衡树
EM LGH
08-23 97
  注意空间大小，以及建树时的细节 #include&lt;cstdio&gt; #include&lt;algorithm&gt; #include&lt;iostream&gt; using namespace std; const int maxn = 5000000 + 3; const int N = 50000+3; const int maxm = 100000000 ...
洛谷P3380：二逼平衡树 （树套树）
KsCla
11-16 2029
题目传送门：https://www.luogu.org/problemnew/show/3380题目分析：为什么我要把这道模板题写在博客上呢？因为我想记录一个卡常的小技巧。骗访问量这题我是考noip之前码的，写的是坐标线段树套动态开节点的权值线段树，虽然空间是O(nlog2(n))O(n\log^2(n))，但实际空间并没有这么大。由于在log(n)\log(n)棵线段树上同时二叉查找，时间是O(m
P3380 【模板】二逼平衡树（树套树）
东君不爱惜
09-14 98
传送门 查询 kkk 在区间内的排名 查询区间内排名为 kkk的值 修改某一位值上的数值 查询 kkk 在区间内的前驱（前驱定义为严格小于 xxx，且最大的数，若不存在输出 −2147483647-2147483647−2147483647） 查询 kkk 在区间内的后继（后继定义为严格大于 xxx，且最小的数，若不存在输出 214748364721474836472147483647） 分析 对于静态区间第K大来说，那就上主席树吧 如果动态的话，就树套树了 如果是双动态的话，那就树套树套树了（大雾）
[洛谷P3380] 二逼平衡树（树套树）
RDJ_Widow的博客
05-11 275
https://www.luogu.org/problemnew/show/P3380 这题我是用线段树+splay写的，第一次写树套树，一开始感觉是个很难想象很难写的事情，但说白了这一题就是线段树的每个区间套一个splay。。。 然后对于第二个操作就是二分答案val，验证rank值。。。 第一个版本写完无限TLE... 改了一个晚上终于改到了洛谷5000多ms，bzoj7200ms。。。...
洛谷P1168 中位数线段树解法
最新发布
07-28
洛谷P1168题目是关于中位数线段树解法的问题。中位数线段树解法可以通过维护两个堆来实现。一个是大根堆，一个是小根堆。每次插入元素时，根据一定的规则来维护这两个堆，使得大根堆的个数在一定情况下比小根堆多1...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值