题目传送门
视频讲解
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
//重定向输入输出
#define FILE_OUT freopen("P5494.out", "w", stdout);
#define FILE_IN freopen("P5494.in", "r", stdin);
//重定义 tr[u].l 和 tr[u].r 快速录入用
#define ls tr[u].lson
#define rs tr[u].rson
const int N = 200010;
int n, m;
int a[N]; //记录原始数组，其实也可以不用保存，直接在build时录入到叶子也可以
int root[N], idx; //分裂出的第几个线段树,idx是序号维护器
struct Node {
int lson, rson; //动态开点,记录左右儿子的节点编号
//注意：这里与普通线段树不同，没有记录当前节点的管辖范围！！！！！
//黄海尝试了记录[l,r]的方法，结果因为结构体内增加了两个属性，同时数组的上限非常大，直接MLE了好多测试点。
LL val; //每一个节点保存的值大小是管辖区间中的个数
} tr[N << 6];
int cnt; //记录tr数组中的可以放入节点的位置
//权值线段树合并,维护区间元素个数
void pushup(int u) {
tr[u].val = tr[ls].val + tr[rs].val;
}
/**
* @brief 构建线段树
*
* @param l 想要创建的节点，是管理哪个范围的，这与普通线段树相似，只不过普通线段树可以事先准备好节点号，这个需要现用现创建，
* 并且需要返回节点号，让父节点记录和父节点的关联关系。
* @param r
* @return int
*/
int build(int l, int r) {
//由于构建之前，空间是未分配状态，需要为新构建的节点分配节点号，节点号就是cnt
int u = ++cnt;
//现在有了可用的节点号了
if (l == r) { //如果是叶子节点
//接下来一行n个整数，表示 1∼n 这些数在a[N]中出现的 **次数**
//其实7就放在[7,7]的位置上，val就记录7这个数字出现的次数
tr[u].val = a[l]; //个数！！！
return u;
}
int mid = (l + r) >> 1;
//由于是动态开点，无法像普通线段树一样，采用预先创建的办法，普通办法只要知道父节点，u<<1 和 u<<1|1就是左右儿子节点号
//而在动态开点的模板中，需要递归创建并返回新建节点编号，由并记录到tr[u].l和tr[u].r上，以实现父子节点的关联对应
ls = build(l, mid), rs = build(mid + 1, r);
//更新父节点统计信息
pushup(u);
return u;
}
/**
* @brief 线段树分裂
*
* @param k 以k为根的线段树
* @param l 左边界
* @param r 右边界
* @param ql 要分裂出的左边界
* @param qr 要分裂出的右边界
* @return int
*/
int spilt(int k, int l, int r, int ql, int qr) {
int u = ++cnt; //分裂后的根节点编号u
if (l == ql && r == qr) { //完全命中区间
tr[u] = tr[k]; //将tr[k]抄到tr[u]
tr[k].val = tr[k].lson = tr[k].rson = 0; //销毁tr[k]
return u; //返回新分裂后的节点编号u
}
int mid = (l + r) >> 1;
if (qr <= mid) //分裂左儿子
ls = spilt(tr[k].lson, l, mid, ql, qr);
else if (ql > mid) //分裂右儿子
rs = spilt(tr[k].rson, mid + 1, r, ql, qr);
else {
ls = spilt(tr[k].lson, l, mid, ql, mid);
rs = spilt(tr[k].rson, mid + 1, r, mid + 1, qr);
}
//递归更新分裂后u和k的父节点信息
pushup(u), pushup(k);
return u;
}
//合并线段树
void merge(int &x, int y) {
if (!(x && y))
x |= y;
else {
tr[x].val += tr[y].val;
merge(tr[x].lson, tr[y].lson);
merge(tr[x].rson, tr[y].rson);
}
}
/**
* @brief 在 u 这个可重集中加入 x 个数字 q
*
* @param u 以u为根
* @param l 左边界
* @param r 右边界
* @param q 数字p
* @param x 增加x个
*/
void insert(int u, int l, int r, int q, int x) {
if (l == r) {
tr[u].val += x; //权值线段树个数增加x个
return;
}
int mid = (l + r) >> 1;
if (q <= mid) {
if (ls == 0) ls = ++cnt; //左儿子不存在，则创建之
insert(ls, l, mid, q, x); //向左儿子递归插入
} else {
if (rs == 0) rs = ++cnt; //右儿子不存在，则创建之
insert(rs, mid + 1, r, q, x); //向右儿子递归插入
}
//向父节点更新统计信息
pushup(u);
}
/**
* @brief 在以u节点为根的线段树中，管辖范围是[l,r],查询区间[ql,qr]内数字的总个数
* 查询可重集 p中大于等于 x 且小于等于 y 的值的个数。
* @param u 根节点
* @param l 左边界
* @param r 右边界
* @param ql 查询左边界
* @param qr 查询右边界
* @return LL 有多少个
*/
LL query(int u, int l, int r, int ql, int qr) {
if (l == ql && r == qr) return tr[u].val;
int mid = (l + r) >> 1;
if (qr <= mid)
return query(ls, l, mid, ql, qr);
else if (ql > mid)
return query(rs, mid + 1, r, ql, qr);
else
return query(ls, l, mid, ql, mid) + query(rs, mid + 1, r, mid + 1, qr);
}
//查询第k小的数
int kth(int u, int l, int r, int k) {
if (l == r) return l;
int mid = (l + r) >> 1;
if (tr[ls].val >= k)
return kth(ls, l, mid, k);
return kth(rs, mid + 1, r, k - tr[ls].val);
}
int main() {
// OJ的环境不使用文件输入输出
#ifndef ONLINE_JUDGE
FILE_IN
FILE_OUT
#endif
//优化读入
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
//范围[1~n],创建第一个线段树，返回值是根节点号，记录到root[1]中
for (int i = 1; i <= n; i++) cin >> a[i];
root[++idx] = build(1, n);
int op, p, x, y;
for (int i = 1; i <= m; i++) {
cin >> op >> p;
if (op == 0) { //将可重集p中大于等于x且小于等于y的值放入一个新的可重集中
//新可重集编号为从2开始的正整数，是上一次产生的新可重集的编号+1。
cin >> x >> y;
root[++idx] = spilt(root[p], 1, n, x, y);
} else if (op == 1) { //合并线段树
cin >> x;
merge(root[p], root[x]); //将根为x的线段树合并到根为p的线段树中去,x线段树以后就不用了
} else if (op == 2) { //在p这个可重集中加入x个数字q
cin >> x >> y;
insert(root[p], 1, n, y, x);
} else if (op == 3) { //区间查询
cin >> x >> y;
printf("%lld\n", query(root[p], 1, n, x, y));
} else {
int k;
cin >> k; //在线段树上二分，如果左孩子的元素个数大于等于k，说明第k小在左子树内；
//否则，在右子树内。
if (query(root[p], 1, n, 1, n) < k)
printf("-1\n");
else
printf("%d\n", kth(root[p], 1, n, k));
}
}
return 0;
}
