P3224 [HNOI2012]永无乡 - 平衡树 - 并查集

开n棵平衡树，慢慢合并成一个，用并查集处理连通关系，平衡树处理第k大就好了
因为重要度是不会有重复的，而且是从1到n的，可以开一个数组，表示重要度为k所对应的编号

要善于把一个新问题转化为一个已解决过的问题
我甚至想自己搞出一个新算法处理连通关系，但是用并查集不就好了吗
思维定势：一个题只用一个学过的算法
实际上用平衡树处理了第k大之后，现在只需要思考如何处理一些点的连通关系，那么并查集就是最适合处理的吧，还能找出代表元素作为合并树之后的树根
合并的时候把size小的合到大的上就好了，这就是启发式合并，和并查集按秩合并一个样。。。

#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;
}