BZOJ2733: [HNOI2012]永无乡

Description

永无乡包含 n 座岛，编号从 1 到 n，每座岛都有自己的独一无二的重要度，按照重要度可以将这 n 座岛排名，名次用 1 到 n 来表示。

某些岛之间由巨大的桥连接，通过桥可以从一个岛到达另一个岛。

如果从岛 a 出发经过若干座（含 0 座）桥可以到达岛 b，则称岛 a 和岛 b 是连通的。

现在有两种操作：

B x y 表示在岛 x 与岛 y 之间修建一座新桥。

Q x k 表示询问当前与岛 x连通的所有岛中第 k 重要的是哪座岛，即所有与岛 x 连通的岛中重要度排名第 k 小的岛是哪座，请你输出那个岛的编号。

Input

输入文件第一行是用空格隔开的两个正整数 n 和 m，分别表示岛的个数以及一开始存在的桥数。

接下来的一行是用空格隔开的 n 个数，依次描述从岛 1 到岛 n 的重要度排名。

随后的 m 行每行是用空格隔开的两个正整数 ai 和 bi，表示一开始就存在一座连接岛 ai 和岛 bi 的桥。

后面剩下的部分描述操作，该部分的第一行是一个正整数 q，表示一共有 q 个操作.

接下来的 q 行依次描述每个操作，操作的格式如上所述，以大写字母 Q 或B 开始，后面跟两个不超过 n 的正整数，字母与数字以及两个数字之间用空格隔开。

对于 20%的数据 n≤1000,q≤1000
对于 100%的数据 n≤100000,m≤n，q≤300000

Output

对于每个 Q x k 操作都要依次输出一行，其中包含一个整数，表示所询问岛屿的编号。

如果该岛屿不存在，则输出-1。

Sample Input

5 1
4 3 2 5 1
1 2
7
Q 3 2
Q 2 1
B 2 3
B 1 5
Q 2 1
Q 2 4
Q 2 3

Sample Output

-1
2
5
1
2

题解Here!

两个操作：连接

本来想法是

所以用并查集

但是合并并查集时，

没事，与线段树相同，我们有

构建

void dfs(int rt,int f){
	if(!rt)return;
	if(a[rt].son[0])dfs(a[rt].son[0],f);
	if(a[rt].son[1])dfs(a[rt].son[1],f);
	insert(a[rt].v,f);//插入一个节点
}
inline void merge(int x,int y){
	x=find(x);y=find(y);//并查集
	if(x==y)return;
	if(a[root[x]].s>a[root[y]].s)swap(x,y);
	father[x]=y;
	dfs(root[x],y);
}

又因为每次合并都要插入操作，查询时不能直接找到原来的岛屿编号，故用了一个

#include<iostream>
#include<algorithm>
#include<cstdio>
#define MAXN 500010
using namespace std;
int n,m,q,size;
int root[MAXN],father[MAXN],id[MAXN];
struct node{
	int f,s,son[2];
	int v;
}a[MAXN];
inline int read(){
	int date=0,w=1;char c=0;
	while(c<'0'||c>'9'){if(c=='-')w=-1;c=getchar();}
	while(c>='0'&&c<='9'){date=date*10+c-'0';c=getchar();}
	return date*w;
}
inline int find(int x){return father[x]==x?x:father[x]=find(father[x]);}
inline void pushup(int rt){
	if(!rt)return;
	a[rt].s=a[a[rt].son[0]].s+a[a[rt].son[1]].s+1;
}
inline void turn(int rt,int k){
	int x=a[rt].f,y=a[x].f;
	a[x].son[k^1]=a[rt].son[k];
	if(a[rt].son[k])a[a[rt].son[k]].f=x;
	a[rt].f=y;
	if(y)a[y].son[a[y].son[1]==x]=rt;
	a[x].f=rt;
	a[rt].son[k]=x;
	pushup(x);pushup(rt);
}
void splay(int rt,int ancestry){
	while(a[rt].f!=ancestry){
		int x=a[rt].f,y=a[x].f;
		if(y==ancestry)turn(rt,a[x].son[0]==rt);
		else{
			int k=a[y].son[0]==x?1:0;
			if(a[x].son[k]==rt){turn(rt,k^1);turn(rt,k);}
			else{turn(x,k);turn(rt,k);}
		}
	}
	if(ancestry<=n)root[ancestry]=rt;
}
inline void insert(int x,int f){
	int rt=root[f],fa=f;
	while(rt&&a[rt].v!=x){
		fa=rt;
		rt=a[rt].son[a[rt].v<x];
	}
	rt=++size;
	if(fa>n)a[fa].son[a[fa].v<x]=rt;
	a[rt].son[0]=a[rt].son[1]=0;
	a[rt].f=fa;a[rt].v=x;
	a[rt].s=1;
	splay(rt,f);
}
void dfs(int rt,int f){
	if(!rt)return;
	if(a[rt].son[0])dfs(a[rt].son[0],f);
	if(a[rt].son[1])dfs(a[rt].son[1],f);
	insert(a[rt].v,f);
}
inline void merge(int x,int y){
	x=find(x);y=find(y);
	if(x==y)return;
	if(a[root[x]].s>a[root[y]].s)swap(x,y);
	father[x]=y;
	dfs(root[x],y);
}
int kth(int f,int k){
	int rt=root[f];
	if(a[rt].s<k)return -1;
	while(1){
		int y=a[rt].son[0];
		if(k>a[y].s+1){
			k-=a[y].s+1;
			rt=a[rt].son[1];
		}
		else if(k<=a[y].s)rt=y;
		else return a[rt].v;
	}
}
void work(){
	int x,y;
	char ch[2];
	q=read();
	while(q--){
		scanf("%s",ch);x=read();y=read();
		if(ch[0]=='B'){
			merge(x,y);
		}
		if(ch[0]=='Q'){
			int ans=kth(find(x),y);
			if(ans==-1)printf("-1
");
			else printf("%d
",id[ans]);
		}
	}
}
void init(){
	int x,y;
	n=read();m=read();
	size=n<<1;
	for(int i=1;i<=n;i++){
		father[i]=i;
		root[i]=i+n;
		x=read();
		a[i+n].v=x;id[x]=i;
		a[i+n].s=1;a[i+n].f=i;
	}
	for(int i=1;i<=m;i++){
		x=read();y=read();
		merge(x,y);
	}
}
int main(){
	init();
	work();
	return 0;
}