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

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

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

分析

树套树

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

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

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

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

树状数组，每次修改需要修改lognlognlogn个节点，总共有nnn个节点
线段树，每次修改需要修改lognlognlogn个节点，总共有2∗n−12*n-12∗n−1个节点

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

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

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

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

整体二分

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

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

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

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

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

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

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

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

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

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

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

如果aaa和bbb都大于midmidmid，都不执行，对此时二分的答案的判定无影响，被分配到右区间
如果aaa和bbb都小于等于midmidmid，此时两个操作都会执行，判定影响为，“−1-1−1然后+1+1+1”也就是不变，两个都被分配到左区间
如果aaa小于等于midmidmid，bbb大于midmidmid，此时aaa执行，bbb不执行，对判定影响为“−1-1−1”，aaa分配到左区间，bbb分在右区间
如果aaa大于midmidmid，bbb小于等于midmidmid，此时aaa不执行，bbb执行，对判定影响为“+1+1+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_INFILE_OUT#endifint 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_INFILE_OUT#endifint T = 1;//cin >> T;while (T--) solve();return AC;
}