BZOJ.4552. [Tjoi2016&Heoi2016]排序【离线二分+线段树】

传送门
给定长度为$N$的序列，再给出$M$次排序操作，$[l,r]$区间排序，递增或者递减两种，最后要求排序后$P$位置的数是什么

分析

由于是不强制在线，我们考虑离线做法
对于一个数来说，它要么大于某个数$X$，要么小于等于$X$
对于这种两面性，我们可以二分答案，把这个数抽象为$1$(小于等于)，$0$(大于)，对01序列进行排序。
01序列可以通过线段树高效维护排序。区间set，区间求和就能解决

代码

// 
/*
  @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;

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

int arr[MAX_N];
int brr[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].lazy = add;
}

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

void build(int rt, int l, int r) {
	tr[rt] = {0, -1};
	if (l == r) {
		tr[rt].k = brr[l];
		return;
	}
	int mid = l + ((r-l)>>1);
	build(rt<<1, l, mid);
	build(rt<<1|1, mid+1, r);
	push_up(rt);
}

void update(int rt, int l, int r, int x, int y, int k) {
	if (x > y) return;
	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) {
	if (x > y) 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(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);
}

struct Opt {
	int l, r, ty;
}opt[MAX_N];

bool check(int mid) {
	for (int i = 1; i <= N; ++i) {
		brr[i] = arr[i] <= mid;
	}
	build(1, 1, N);
	int l, r, one;
	for (int i = 1; i <= M; ++i) {
		one = query(1, 1, N, l = opt[i].l, r = opt[i].r);
		if (!opt[i].ty) {
			update(1, 1, N, l, l + one - 1, 1);
			update(1, 1, N, l+one, r, 0);
		} else {
			update(1, 1, N, l, r-one, 0);
			update(1, 1, N, r-one+1, r, 1);
		}
	}
	return query(1, 1, N, K, K);
}

void solve(){
	sc("%lld%lld", &N, &M);
	for (int i = 1; i <= N; ++i) {
		sc("%lld", &arr[i]);
	}
	for (int i = 1; i <= M; ++i) {
		sc("%lld%lld%lld", &opt[i].ty, &opt[i].l, &opt[i].r);
	}
	
	sc("%lld", &K);
	int l = 1, r = N, mid = 0, ans = 1;
	while (l <= r) {
		mid = l + ((r-l)>>1);
		if (check(mid)) {
			ans = mid;
			r = mid-1;
		} else {
			l = mid+1;
		}
	}
	pr("%lld", ans);
}

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

	return AC;
}