P2617 Dynamic Rankings 动态区间第K大【树套树】或【整体二分】

传送门
动态区间第$K$大问题，单点修改（这里是第$k$小，即是从小到大第$k$个）

这里还有个区间修改，有点类似的 P3332 [ZJOI2013]K大数查询

分析

树套树

树套树，就是用一种树形结构维护另一个数据结构
形式多样，根据需求定制

这里是，动态区间第$K$大
考虑静态的情况下，解法有
在线：主席树，划分树
离线：整体二分

如果要支持修改，划分树是根据最终结果排序后再构造出来的树，所以不资瓷修改
剩下的，主席树和整体二分了，整体二分下面再说

主席树静态区间，每一个版本的值域情况
对每一个位置构造一个权值线段树，但是使用了前面的信息，也就是在更新的时候，进行了克隆原来版本的信息，克隆之后在版本中更新，大大减少了空间使用
假如我修改了$i$位置的信息，由于存在依赖关系（上面的关系就是），就需要修改$i+1$位置的权值线段树信息，一直修改到最后
这样每次修改最坏的复杂度就是 $nlogn$，明显不优
我们深层次考虑静态区间第$K$大的本质
我们对于每一个位置建立一个权值线段树，这个位置上的权值线段树，就是这个位置前面的数，数量的一个前缀和
修改时要修改后面的信息，目的就是维护这个前缀和
那么我们有什么数据结构能够解决这个前缀和问题呢？
树状数组或者是线段树

• 树状数组，每次修改需要修改$logn$个节点，总共有$n$个节点
• 线段树，每次修改需要修改$logn$个节点，总共有$2\ast n-1$个节点

这里权衡时间和空间的复杂度，使用树状数组进行外层树形结构，维护内层的权值线段树（事实上，树状数组也写起来更简单，这种动态开点线段树最怕的就是空间问题，小了不行，大了$MLE$）

那么，树状数组维护的过程中，需要修改$logn$个节点，我们只在这几个节点上进行修改，最后我们查询查这$logn$个节点的信息才是对的。
这里注意，每次询问前我们都要预先处理好这$logn$个节点，便于我们在询问的时候求前缀和，获取版本信息

修改问题解决了，查询就只需要在树上进行二分查找即可
先求出当前版本的左边一半的数有多少个（对右边$logn$个节点求值，减去左边$logn$个节点的值），记为$x$

• 如果小于$k$则往右边找，$k-=x$，往右边找第$k-x$大的
• 如果大于$k$则往左边找，说明答案一定是在左边第$k$大

---

整体二分

先考虑静态的，对每一个查询都保存下来，记为查询询问
把每一个下标对应的数和下标也保存下来，记为插入询问
可以预先离散化一下出现的值
对第$k$大进行二分

假设当前二分答案为$mid$
把所有插入询问中值小于$mid$（或者是$mid$代表的值）的位置上加$1$，且分到左区间，其它的分到右区间

对所有的查询询问，查询当前答案下，$l\sim r$ 区间有多少个打上了标记$1$，也就是查区间和，记为$cnt$

• 如果 $cnt$ 小于等于 $k$，说明答案在大的区间，把这个询问放在右区间，因为左边已经有了$cnt$个，所以答案在右区间的第$k-cnt$小，$k$要减去$cnt$
• 如果 $cnt$ 大于 $k$，说明答案在小的区间，把这个询问放在左区间，$k$不用变，因为答案仍然是左区间第$k$小

二分的过程中，在取等于条件的那里临时记录答案
即是在，小于等于那里记录
这里笔者采用的是如下的二分形式，注意一下和其它的二分格式
这里是二分过程中记录答案，并且更新答案（这样好理解些）

while (l <= r) {
	mid = l + ((r-l)>>1);
	if (check(mid)) {
		ans = mid;
		l = mid + 1;
	} else {
		r = mid - 1;
	}
}

对于上面插入询问 的分左右问题，这里做下解释：
左区间为答案小的区间，右区间为答案大的区间
如果一个插入的值大于当前的$mid$的话，不会给小区间的答案造成影响（小区间不会使用到这个插入询问，这个位置上一定不会被置为$1$），只有右边区间才会使用到，所以放在右边，小于的同理

接下来，考虑动态的
由于动态多了一个操作，会单点修改某一个值
这里我们同样可以把修改操作加入到插入询问中
前面的常规的插入操作是，在某一个位置加 $1$
这里修改操作可以分解为

• 在某一个位置$-1$（删去原先的值影响）
• 在这个位置上$+1$（修改为当前的值）

为什么能够保证这里的正确性呢？
因为初始的插入询问一定在所有询问前，完成初始化的效果
之后的修改操作，以及查询操作，都是按时间顺序进行二分的

这里大概证明一下：
如果当前二分的答案是$mid$，某个位置修改前为$a$，修改后为$b$

• 如果$a$和$b$都大于$mid$，都不执行，对此时二分的答案的判定无影响，被分配到右区间
• 如果$a$和$b$都小于等于$mid$，此时两个操作都会执行，判定影响为，“$-1$然后$+1$”也就是不变，两个都被分配到左区间
• 如果$a$小于等于$mid$，$b$大于$mid$，此时$a$执行，$b$不执行，对判定影响为“$-1$”，$a$分配到左区间，$b$分在右区间
• 如果$a$大于$mid$，$b$小于等于$mid$，此时$a$不执行，$b$执行，对判定影响为“$+1$”

综上，这个修改操作无论在什么情况都只会执行影响判定的那一部分，且和真实修改情况一致，正确性显然

---

代码

树套树

//P3380
/*
  @Author: YooQ
*/
#include <bits/stdc++.h>
using namespace std;
#define sc scanf
#define pr printf
#define ll 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, l, r, k;
}qr[MAX_N];

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

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 k) {
	if (!rt) rt = ++indx;
	if (l == r) {
		tr[rt].k += k;
		return;
	}
	int mid = l + ((r-l)>>1);
	if (x <= mid) update(tr[rt].l, l, mid, x, k);
	if (x  > mid) update(tr[rt].r, mid+1, r, x, k);
	push_up(rt);
}


int cnt[2];
int son[2][MAX_N];
int ans[2][MAX_N];

int query(int l, int r, int k) {
	if (l == r) {
		return l;
	}
	int mid = l + ((r-l)>>1);
	int sum = 0;
	int lsum = 0;
	for (int i = 1; i <= cnt[1]; ++i) {
		sum += tr[son[1][i]].k;
		lsum += tr[tr[son[1][i]].l].k;
	}
	for (int i = 1; i <= cnt[0]; ++i) {
		sum -= tr[son[0][i]].k;
		lsum -= tr[tr[son[0][i]].l].k;
	}
	if (sum < k) return 0;
	if (lsum >= k) {
		for (int i = 1; i <= cnt[0]; ++i) {
			son[0][i] = tr[son[0][i]].l;
		}
		for (int i = 1; i <= cnt[1]; ++i) {
			son[1][i] = tr[son[1][i]].l;
		}
		return query(l, mid, k);
	} else {
		for (int i = 1; i <= cnt[0]; ++i) {
			son[0][i] = tr[son[0][i]].r;
		}
		for (int i = 1; i <= cnt[1]; ++i) {
			son[1][i] = tr[son[1][i]].r;
		}
		return query(mid+1, r, k-lsum);
	}
}

inline int lowbit(int x) {
	return x & -x;
}

void modify(int x, int k) {
	int val = arr[x];
	while (x <= N) {
		update(root[x], 1, unicnt, val, k);
		x += lowbit(x);
	}
}

int ask(int l, int r, int k) {
	cnt[0] = cnt[1] = 0;
	for (int i = l-1; i; i-=lowbit(i)) {
		son[0][++cnt[0]] = root[i];
	}
	for (int i = r; i; i-=lowbit(i)) {
		son[1][++cnt[1]] = root[i];
	}
	return query(1, unicnt, k);
} 

void solve(){
	sc("%d%d", &N, &M);
	for (int i = 1; i <= N; ++i) {
		sc("%d", &arr[i]);
		uniarr[i] = arr[i];
	}
	unicnt = N;
	int l, r, k;
	char opt[5];
	for (int i = 1; i <= M; ++i) {
		sc("%s%d%d", opt, &l, &r);
		if (*opt == 'Q') {
			sc("%d", &k);
			qr[i] = {0, l, r, k};
		} else {
			qr[i] = {1, l, r, 0};
			uniarr[++unicnt] = r;
		}
	}
	sort(uniarr+1, uniarr+1+unicnt);
	unicnt = unique(uniarr+1, uniarr+1+unicnt) - uniarr - 1;
	
	for (int i = 1; i <= N; ++i) {
		arr[i] = lower_bound(uniarr+1, uniarr+1+unicnt, arr[i]) - uniarr;
		modify(i, 1);
	}
	
	for (int i = 1; i <= M; ++i) {
		if (qr[i].opt) {
			qr[i].r = lower_bound(uniarr+1, uniarr+1+unicnt, qr[i].r) - uniarr;
			modify(qr[i].l, -1);
			arr[qr[i].l] = qr[i].r;
			modify(qr[i].l, 1);
		} else {
			pr("%d\n", uniarr[ask(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;
}

整体二分

//P2617
/*
  @Author: YooQ
*/
#include <bits/stdc++.h>
using namespace std;
#define sc scanf
#define pr printf
#define ll 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, l, r, k, id;
}qr[MAX_N], L[MAX_N], R[MAX_N];

int tr[MAX_N];
inline int lowbit(int x) {
	return x & -x;
}

inline void add(int x, int k) {
	while (x <= N) {
		tr[x] += k;
		x += lowbit(x);
	}
}

inline int ask(int x) {
	int res = 0;
	while (x) {
		res += tr[x];
		x -= lowbit(x);
	}
	return res;
}

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 == 0) {
			if (qr[i].k <= uniarr[mid]) {
				add(qr[i].l, qr[i].id);
				L[++lx] = qr[i];
			} else {
				R[++rx] = qr[i];
			}
		} else {
			int cnt = ask(qr[i].r) - ask(qr[i].l-1);
			if (qr[i].k <= cnt) {
				ans[qr[i].id] = uniarr[mid];
				L[++lx] = qr[i];
			} else {
				qr[i].k -= cnt;
				R[++rx] = qr[i];
			}
		}
	}
	
	for (int i = 1; i <= lx; ++i) {
		if (L[i].opt == 0) add(L[i].l, -L[i].id);
		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("%d%d", &N, &M);
	int cnt = 0;
	for (int i = 1; i <= N; ++i) {
		sc("%d", &arr[i]);
		qr[++cnt] = {0, i, i, arr[i], 1};
		uniarr[++unicnt] = arr[i];
	}
	
	int l, r, k;
	char opt[5];
	int qcnt = 0;
	for (int i = 1; i <= M; ++i) {
		sc("%s%d%d", opt, &l, &r);
		if (*opt == 'Q') {
			sc("%d", &k);
			qr[++cnt] = {1, l, r, k, ++qcnt};
		} else {
			uniarr[++unicnt] = r;
			qr[++cnt] = {0, l, l, arr[l], -1};
			arr[l] = r;
			qr[++cnt] = {0, l, l, arr[l], 1};
		}
	}
	
	sort(uniarr+1, uniarr+unicnt+1);
	unicnt = unique(uniarr+1, uniarr+1+unicnt) - uniarr - 1;
	
	div(1, unicnt, 1, cnt);
	
	for (int i = 1; i <= qcnt; ++i) {
		pr("%d\n", ans[i]);
	}
}

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

	return AC;
}