P3332 [ZJOI2013]K大数查询【整体二分】或【树套树】-优快云博客

这篇博客介绍了如何解决区间可重集合动态查询第K大元素的问题，提供了两种方法：树套树（线段树套线段树）和整体二分。在树套树的方法中，通过外层线段树维护区间信息，内层使用动态开点权值线段树处理单点修改。整体二分方法则利用区间修改与单点修改的本质相似性，将单点修改推广到区间修改，同样使用线段树进行维护。博客还给出了具体的C++实现代码供读者参考。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

传送门
给定一个长度为 $N$ 的可重集合
支持修改，离线
求区间可重集合的并集第K大
这里介绍两种方法【树套树】和【整体二分】

这里还有个单点修改，有点类似的 P2617 Dynamic Rankings 动态区间第K大

分析

树套树

对于区间第K大，支持修改，自然会想到树套树
经典的树套树，求动态区间第K大的时候
用树状数维护版本信息，主席树（权值线段树）用来记录当前版本下的信息
接下来求区间第 $K$ 大，在树上进行二分

重点，由于树状数组解决的是单点修改的问题，我们要解决区间修改，就得使用线段树进行维护了，可以看上面那题里面的分析，这里引用一下

我们深层次考虑静态区间第 $K$ 大的本质
我们对于每一个位置建立一个权值线段树，这个位置上的权值线段树，就是这个位置前面的数，数量的一个前缀和
修改时要修改后面的信息，目的就是维护这个前缀和
那么我们有什么数据结构能够解决这个前缀和问题呢？
树状数组或者是线段树

树状数组，每次修改需要修改 $l o g n$ 个节点，总共有 $n$ 个节点
线段树，每次修改需要修改 $l o g n$ 个节点，总共有 $2 * n - 1$ 个节点

这里由于是可重集，区间修改，树状数组解决不了（或者说难以解决），可以使用一颗简单的线段树维护一下区间信息（那么自然的空间也会开得更大了，即使是动态开点）

分析到这，做法就比较显然了
区间修改就在外围线段树中，修改区间内的权值线段树的权值即可，内层是一个区间加和查询区间和的动态开点权值线段树
查询，在外围线段树中二分找值即可

整体二分

区间修改和单点修改没有太大区别
因为都是根据修改前的值和修改后的值来判断是否执行的（这里在上面的另一篇题解中有大概的证明，建议看一下）
与区间大小无关，所以能够由单点修改推广到区间修改
只不过不能用树状数组维护了而已，这里改为线段树维护

代码

树套树【线段树套线段树】

//P3332 
/*
  @Author: YooQ
*/
#include <bits/stdc++.h>
using namespace std;
#define sc scanf
#define pr printf
#define ll long long
#define int long long
#define FILE_OUT freopen("out", "w", stdout);
#define FILE_IN freopen("in", "r", stdin);
#define debug(x) cout << #x << ": " << x << "\n";
#define AC 0
#define WA 1
#define INF 0x3f3f3f3f
const ll MAX_N = 1e6+5;
const ll MOD = 1e9+7;
int N, M, K;

int uniarr[MAX_N];
int unicnt = 0;

struct Tr {
	int k, lazy, l, r;
}tr[MAX_N<<4];
int indx = 0;
int root[MAX_N];

void calc(int& rt, int len, int k) {
	if (!rt) rt = ++indx;
	tr[rt].k += len * k;
	tr[rt].lazy += k;
}

void push_down(int rt, int l, int r) {
	if (!tr[rt].lazy) return;
	int mid = l + ((r-l)>>1);
	calc(tr[rt].l, mid-l+1, tr[rt].lazy);
	calc(tr[rt].r, r-mid, tr[rt].lazy);
	tr[rt].lazy = 0;
}

void push_up(int rt) {
	tr[rt].k = tr[tr[rt].l].k + tr[tr[rt].r].k;
}

void update(int& rt, int l, int r, int x, int y, int k) {
	if (!rt) rt = ++indx;
	if (x <= l && r <= y) {
		calc(rt, r-l+1, k);
		return;
	}
	push_down(rt, l, r);
	int mid = l + ((r-l)>>1);
	if (x <= mid) update(tr[rt].l, l, mid, x, y, k);
	if (y  > mid) update(tr[rt].r, mid+1, r, x, y, k);
	push_up(rt);
}

int query(int rt, int l, int r, int x, int y) {
	if (!rt) return 0;
	if (x <= l && r <= y) {
		return tr[rt].k;
	}
	push_down(rt, l, r);
	int mid = l + ((r-l)>>1);
	if (y <= mid) return query(tr[rt].l, l, mid, x, y);
	if (x  > mid) return query(tr[rt].r, mid+1, r, x, y);
	return query(tr[rt].l, l, mid, x, y) + query(tr[rt].r, mid+1, r, x, y);
}

void add(int rt, int l, int r, int p, int x, int y) {
	update(root[rt], 1, N, x, y, 1);
	if (l == r) {
		return;
	}
	int mid = l + ((r-l)>>1);
	if (p <= mid) add(rt<<1, l, mid, p, x, y);
	if (p  > mid) add(rt<<1|1, mid+1, r, p, x, y);
}

int ask(int rt, int l, int r, int x, int y, int k) {
	if (l == r) return l;
	int mid = l + ((r-l)>>1);
	int sum = query(root[rt<<1|1], 1, N, x, y);
	if (sum < k) return ask(rt<<1, l, mid, x, y, k-sum);
	else return ask(rt<<1|1, mid+1, r, x, y, k);
}

struct Qr {
	int opt, l, r, k;
}qr[MAX_N];

void solve(){
	sc("%lld%lld", &N, &M);
	
	int opt, l, r, k;
	for (int i = 1; i <= M; ++i) {
		sc("%lld%lld%lld%lld", &opt, &l, &r, &k);
		qr[i] = {opt, l, r, k};
		if (opt == 1) uniarr[++unicnt] = k;
	}
	
	sort(uniarr+1, uniarr+1+unicnt);
	unicnt = unique(uniarr+1, uniarr+1+unicnt) - uniarr - 1;

	for (int i = 1; i <= M; ++i) {
		if (qr[i].opt == 1) {
			qr[i].k = lower_bound(uniarr+1, uniarr+1+unicnt, qr[i].k) - uniarr;
			add(1, 1, unicnt, qr[i].k, qr[i].l, qr[i].r);
		} else {
			pr("%lld\n", uniarr[ask(1, 1, unicnt, qr[i].l, qr[i].r, qr[i].k)]);
		}
	}
}

signed main()
{
	#ifndef ONLINE_JUDGE
	//FILE_IN
	FILE_OUT
	#endif
	int T = 1;//cin >> T;
	while (T--) solve();

	return AC;
}

整体二分

// 
/*
  @Author: YooQ
*/
#include <bits/stdc++.h>
using namespace std;
#define sc scanf
#define pr printf
#define ll long long
#define int long long
#define FILE_OUT freopen("out", "w", stdout);
#define FILE_IN freopen("in", "r", stdin);
#define debug(x) cout << #x << ": " << x << "\n";
#define AC 0
#define WA 1
#define INF 0x3f3f3f3f
const ll MAX_N = 1e6+5;
const ll MOD = 1e9+7;
int N, M, K;

int arr[MAX_N];
int uniarr[MAX_N];
int unicnt = 0;

struct Qr {
	int opt, k, l, r, id;
}qr[MAX_N], L[MAX_N], R[MAX_N];

struct Tr {
	int k, add;
}tr[MAX_N];

void push_up(int rt) {
	tr[rt].k = tr[rt<<1].k + tr[rt<<1|1].k;
}

void calc(int rt, int len, int add) {
	tr[rt].k += len * add;
	tr[rt].add += add;
}

void push_down(int rt, int l, int r) {
	if (!tr[rt].add) return;
	int mid = l + ((r-l)>>1);
	calc(rt<<1, mid-l+1, tr[rt].add);
	calc(rt<<1|1, r-mid, tr[rt].add);
	tr[rt].add = 0;
}

void update(int rt, int l, int r, int x, int y, int k) {
	if (x <= l && r <= y) {
		calc(rt, r-l+1, k);
		return;
	}
	push_down(rt, l, r);
	int mid = l + ((r-l)>>1);
	if (x <= mid) update(rt<<1, l, mid, x, y, k);
	if (y  > mid) update(rt<<1|1, mid+1, r, x, y, k);
	push_up(rt);
}

int query(int rt, int l, int r, int x, int y) {
//	cerr << "Qrt: " << rt << " l: " << l << " r: " << r << " x: " << x << " y: " << y << "\n";
	if (x <= l && r <= y) {
		return tr[rt].k;
	}
	push_down(rt, l, r);
	int mid = l + ((r-l)>>1);
	if (y <= mid) return query(rt<<1, l, mid, x, y);
	if (x  > mid) return query(rt<<1|1, mid+1, r, x, y);
	return query(rt<<1, l, mid, x, y) + query(rt<<1|1, mid+1, r, x, y);
}

int ans[MAX_N];

void div(int l, int r, int x, int y) {
	if (l > r) return;
	int mid = l + ((r-l)>>1);
	int lx = 0;
	int rx = 0;
	for (int i = x; i <= y; ++i) {
		if (qr[i].opt == 1) {
			if (qr[i].k >= uniarr[mid]) {
				update(1, 1, N, qr[i].l, qr[i].r, 1);
				R[++rx] = qr[i];
			} else {
				L[++lx] = qr[i];
			}
		} else {
			int cnt = query(1, 1, N, qr[i].l, qr[i].r);
			if (cnt < qr[i].k) {
				qr[i].k -= cnt;
				L[++lx] = qr[i];
			} else {
				R[++rx] = qr[i];
				ans[qr[i].id] = uniarr[mid];
			}
		}
	}
	
	for (int i = 1; i <= rx; ++i) {
		if (R[i].opt == 1) {
			update(1, 1, N, R[i].l, R[i].r, -1);
		}
	}
	
	
	for (int i = 1; i <= lx; ++i) {
		qr[x+i-1] = L[i];
	}
	for (int i = 1; i <= rx; ++i) {
		qr[x+lx-1+i] = R[i];
	}
	
	div(l, mid-1, x, x+lx-1);
	div(mid+1, r, x+lx, y);
}

void solve(){
	sc("%lld%lld", &N, &M);
	int qcnt = 0;
	for (int i = 1; i <= M; ++i) {
		sc("%lld%lld%lld%lld", &qr[i].opt, &qr[i].l, &qr[i].r, &qr[i].k);
		if (qr[i].opt == 2) qr[i].id = ++qcnt;
		else uniarr[++unicnt] = qr[i].k;
	}
	
	sort(uniarr+1, uniarr+1+unicnt);
	unicnt = unique(uniarr+1, uniarr+1+unicnt) - uniarr - 1;
	
	div(1, unicnt, 1, M);
	
	for (int i = 1; i <= qcnt; ++i) {
		pr("%lld\n", ans[i]);
	}
	
}

signed main()
{
	#ifndef ONLINE_JUDGE
	//FILE_IN
	FILE_OUT
	#endif
	int T = 1;//cin >> T;
	while (T--) solve();

	return AC;
}