Dynamic Rankings 带修主席树（主席树 + 主席树维护树状数组）
学带修主席树的起因是vp吉林省赛的时候队友没看数据范围，然后上网查动态求逆序对，发现是带修主席树，批判我为什么不会，并要求我去学。学完之后发现带修主席树根本过不去，被卡内存了。
这场的F其实暴力即可
个人学完这个板子之后觉得板子应该是没有需要动的情况，觉得能做的就是只有动态维护每个位置上的第k小值和维护逆序对数量。
原理什么的就不说了，自己查一查资料，我觉得对于这种我改不了板子的题没啥必要去讲原理。
讲讲修改操作怎么用吧，想要在一个位置pos消除某个数值离散花后对应的v对查询的影响，直接MHST.add（pos，v,-1）；
想要在一个位置pos增加某个数值离散花后对应的v对查询的影响，直接MHST.add（pos，v, 1）；
对于查询操作[l, r]需要提前把对应的位置的根存起来，然后进行query查找。
真不知道这板子能咋改，所以把板子抄来对着题目学一学怎么用就行了，感觉原理不重要。
#include <iostream>
#include <cstring>
#include <iomanip>
#include <algorithm>
#include <stack>
#include <queue>
#include <numeric>
#include <cassert>
#include <bitset>
#include <cstdio>
#include <vector>
#include <unordered_set>
#include <cmath>
#include <map>
#include <unordered_map>
#include <set>
#include <deque>
#include <tuple>
#define all(a) a.begin(), a.end()
#define cnt0(x) __builtin_ctz(x)
#define endl '\n'
#define itn int
#define ll long long
#define ull unsigned long long
#define rep(i, a, b) for(int i = a;i <= b; i ++)
#define per(i, a, b) for(int i = a;i >= b; i --)
#define cntone(x) __builtin_popcount(x)
#define db double
#define fs first
#define se second
#define AC main(void)
#define HYS std::ios::sync_with_stdio(false);std::cin.tie(0);std::cout.tie(0);
typedef std::pair<int, int > PII;
typedef std::pair<int, std::pair<int, int>> PIII;
typedef std::pair<ll, ll> Pll;
typedef std::pair<double, double> PDD;
using ld = double long;
const long double eps = 1e-9;
const int N = 6e4 + 10;
int n , m, _;
int a[N];
struct node{
int l, r, cnt;
}tr[N * 35];
struct Modify_Historical_Segment_Tree{
int idx;
//s是树状数组需要用到的根节点
int root[N], S[N], maxm, stk[N], top;
//查询时用到的两个数组
int qr[N], ql[N];
inline void init(){
idx = top = 0;
}
inline int lowbit(int x) {return x & -x;}
inline int build(int l, int r){
int q = ++ idx;
tr[q].cnt = 0;
if(l == r) return q;
int mid = l + r >> 1;
tr[q].l = build(l, mid);//存的是左儿子的编号并非边界
tr[q].r = build(mid + 1, r);
return q;
}
//需要用到的上一个版本root[i - 1](返回的值是当前版本的root) l,r是离散化后的区间范围 需要添加的离散化后的值x sum是添加的数量
inline int insert(int p, int l, int r, int x, int sum){
int q = ++ idx;
tr[q] = tr[p];//复制上一个节点的信息
if(l == r){
tr[q].cnt += sum;//新版本的信息加1
return q;
}
int mid = l + r >> 1;
if(x <= mid) tr[q].l = insert(tr[p].l, l, mid, x, sum);//在左子树则需要更新信息，否则保留原本信息就可以
else tr[q].r = insert(tr[p].r, mid + 1, r, x, sum);
tr[q].cnt = tr[tr[q].l].cnt + tr[tr[q].r].cnt;
return q;
}
//位置为p 改变离散化后值为x的数量 数量
inline void add(int p, int x, int sum){
//maxm是树状数组数据离散化后的范围
while(p <= maxm){
S[p] = insert(S[p], 1, maxm, x, sum);
p += lowbit(p);
}
}
//flag 表示是查询哪个数组 1 表示qr数组 0表示ql数组 查询的是左半边修改的数量总和
inline int Sum(int x, int flag){
int res = 0;
while(x){
if(flag) res += tr[tr[qr[x]].l].cnt;
else res += tr[tr[ql[x]].l].cnt;
x -= lowbit(x);
}
return res;
}
//我们需要查询1 - lt这个区间在树状数组中左半边修改的总数量所以一般传入l - 1
//我们需要查询1 - nw这个区间在树状数组中左半边修改的总数量
// lt nw 是需要去树状数组里面求的版本号所以不用每次query不用改
inline int query(int lt, int nw, int p, int q, int l, int r, int k){//区间k小
if(l == r) return l;
int mid = l + r >> 1;
int cnt = Sum(nw, 1) - Sum(lt, 0) + tr[tr[q].l].cnt - tr[tr[p].l].cnt;
if(cnt >= k){
//因为区间是逐渐缩小的，所有我们对应 方便Sum去求一个子区间的修改的总数量
for(int i = nw; i; i -= lowbit(i)) qr[i] = tr[qr[i]].l;
for(int i = lt; i; i -= lowbit(i)) ql[i] = tr[ql[i]].l;
return query(lt, nw, tr[p].l, tr[q].l, l, mid, k);
}
else{
for(int i = nw; i; i -= lowbit(i)) qr[i] = tr[qr[i]].r;
for(int i = lt; i; i -= lowbit(i)) ql[i] = tr[ql[i]].r;
return query(lt, nw, tr[p].r, tr[q].r, mid + 1, r, k - cnt);
}
}
}MHST;
struct Query{
int op, l, r, k;
}q[N];
inline void solve(){
std::cin >> n >> m;
std::vector<int> nums;
MHST.init();
std::vector<int> pos(n + 1);
for(int i = 1; i <= n; i ++){
std::cin >> a[i];
nums.emplace_back(a[i]);
}
for(int i = 1; i <= m; i ++){
char ch;
std::cin >> ch;
if(ch == 'Q'){
q[i].op = 1;
std::cin >> q[i].l >> q[i].r >> q[i].k;
}
else{
q[i].op = 0;
std::cin >> q[i].l >> q[i].r;
nums.emplace_back(q[i].r);
}
}
std::sort(nums.begin(), nums.end());
nums.erase(std::unique(nums.begin(), nums.end()), nums.end());
int sz = nums.size();
MHST.maxm = sz;
for(int i = 1; i <= n; i ++) pos[i] = std::lower_bound(nums.begin(), nums.end(), a[i]) - nums.begin() + 1;
auto &root = MHST.root, &S = MHST.S, &qr = MHST.qr, &ql = MHST.ql;
root[0] = MHST.build(1, sz);
for(int i = 1; i <= n; i ++) root[i] = MHST.insert(root[i - 1], 1, sz, pos[i], 1);
for(int i = 1; i <= sz; i ++) S[i] = root[0];
for(int i = 1; i <= m; i ++){
if(q[i].op){
int l = q[i].l - 1, r = q[i].r, k = q[i].k;
for(int j = r; j; j -= MHST.lowbit(j)) qr[j] = S[j];
for(int j = l; j; j -= MHST.lowbit(j)) ql[j] = S[j];
std::cout << nums[MHST.query(l, r, root[l], root[r], 1, sz, k) - 1] << '\n';
}else{
int x = std::lower_bound(nums.begin(), nums.end(), a[q[i].l]) - nums.begin() + 1;
MHST.add(q[i].l, x, -1);
a[q[i].l] = q[i].r;
x = std::lower_bound(nums.begin(), nums.end(), a[q[i].l]) - nums.begin() + 1;
MHST.add(q[i].l, x, 1);
}
}
}
signed AC{
HYS
std::cin >> _;
while(_ --)
solve();
return 0;
}
