开n棵平衡树,慢慢合并成一个,用并查集处理连通关系,平衡树处理第k大就好了
因为重要度是不会有重复的,而且是从1到n的,可以开一个数组,表示重要度为k所对应的编号
如何合并?
要善于把一个新问题转化为一个已解决过的问题
我甚至想自己搞出一个新算法处理连通关系,但是用并查集不就好了吗
思维定势:一个题只用一个学过的算法
实际上用平衡树处理了第k大之后,现在只需要思考如何处理一些点的连通关系,那么并查集就是最适合处理的吧,还能找出代表元素作为合并树之后的树根
合并的时候把size小的合到大的上就好了,这就是启发式合并,和并查集按秩合并一个样。。。
如何用并查集处理?
我们只知道某个点所在集合的代表元素,但是代表元素不一定是树根,所以还要再开一个数组,rt[i]表示i点所在的树的树根,然后用树根的权值映射出点的编号就好了。如何维护?若我们要把a树合并到b树上,先把a所在的集合合并到b上,使ab集合的代表元素仍然是b集合的代表元素,那么r[a]是什么已经无所谓了,只需要维护r[b],对平衡树搞启发式合并的时候动态维护就好了(就是函数里加个引用)
#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
#define debug(x) cerr << #x << "=" << x << endl;
const int MAXN = 200000 + 10;
typedef long long ll;
struct fhq_treap{
int l, r, siz, val, rnd;
}tr[MAXN];
int n,a[MAXN],root,x,y,z,rt[MAXN],fa[MAXN],tot,m,q,rev[MAXN];
inline void read(int &x) {
x = 0;
char ch = getchar();
while(ch < '0' || ch > '9') ch = getchar();
while(ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
}
void update(int now) {
tr[now].siz = tr[tr[now].l].siz + tr[tr[now].r].siz + 1;
}
int newnode(int x) {
tr[++tot].val = x;
tr[tot].rnd = rand();
tr[tot].siz = 1;
return tot;
}
int merge(int x, int y) {
if(!x || !y) return x + y;
if(tr[x].rnd < tr[y].rnd) {
tr[x].r = merge(tr[x].r, y);
update(x);
return x;
}
tr[y].l = merge(x, tr[y].l);
update(y);
return y;
}
void split(int now, int k, int &x, int &y) {
if(!now) {
x = y = 0;
return;
}
if(tr[now].val <= k) {
x = now;
split(tr[now].r, k, tr[now].r, y);
} else {
y = now;
split(tr[now].l, k, x, tr[now].l);
}
update(now);
}
int kth(int now, int k) {
while(1) {
int ls = tr[now].l, rs = tr[now].r;
if(k <= tr[ls].siz) {
now = ls;
} else {
if(k == tr[ls].siz+1) return now;
k -= tr[ls].siz + 1;
now = rs;
}
}
}
int find(int x){
return x == fa[x] ? x : fa[x] = find(fa[x]);
}
void ufs_merge(int x, int y) {
int fx = find(x), fy = find(y);
fa[fx] = fy;
}
bool judge(int x, int y) {
return find(x) == find(y);
}
void trav(int now, int &tar) {
if(!now) return;
int val = tr[now].val;
split(tar, val, x, y);
tar = merge(merge(x, newnode(val)), y);
trav(tr[now].l, tar);
trav(tr[now].r, tar);
}
void heu_merge(int a, int b) {
if(tr[rt[a]].siz > tr[rt[b]].siz) swap(a, b);
ufs_merge(a, b);
trav(rt[a], rt[b]);
}
int main() {
scanf("%d%d", &n, &m);
for(int i=1; i<=n; i++) {
int temp_val = 0;
read(temp_val);
rev[temp_val] = i;
rt[i] = merge(rt[i], newnode(temp_val));
}
for(int i=1; i<=n; i++) {
fa[i] = i;
}
for(int i=1; i<=m; i++) {
int ai, bi;
read(ai), read(bi);
if(!judge(ai, bi)) {
heu_merge(find(ai), find(bi));
}
}
scanf("%d", &q);
char ch[5];
for(int i=1; i<=q; i++) {
int x, y;
scanf("%s%d%d", ch, &x, &y);
if(ch[0] == 'Q') {
int sym = find(x);
if(y > tr[rt[sym]].siz) {
printf("-1\n");
} else {
printf("%d\n",rev[tr[kth(rt[sym], y)].val]);
}
} else {
if(!judge(x, y)) {
heu_merge(find(x), find(y));
}
}
}
return 0;
}