bzoj3123 & 洛谷3302 [SDOI2013]森林 启发式合并+主席树+并查集

题目链接：
洛咕3302
bzoj3123

小Z有一片森林，含有N个节点，每个节点上都有一个非负整数作为权值。初始的时候，森林中有M条边。

小Z希望执行T个操作，操作有两类：

Q x y k查询点x到点y路径上所有的权值中，第k小的权值是多少。此操作保证点x和点y连通，同时这两个节点的路径上至少有k个点。
L x y在点x和点y之间连接一条边。保证完成此操作后，仍然是一片森林。
为了体现程序的在线性，我们把输入数据进行了加密。

神仙题……
第k小想到树上主席树。
合并时发现一个困难的地方：当合并$x,y$时，$x,y$不一定是自己所在树的根。
所以启发式合并，每次暴力重构节点数小的树，接到大的树上即可qwq。
细节一堆，要调一年……

毒瘤代码

#include<stdio.h>
#include<cstring>
#include<algorithm>
#include<vector>
#define re register int
#define rl register ll
using namespace std;
typedef long long ll;
int read() {
	re x=0,f=1;
	char ch=getchar();
	while(ch<'0' || ch>'9') {
		if(ch=='-')	f=-1;
		ch=getchar();
	}
	while(ch>='0' && ch<='9') {
		x=(x<<1)+(x<<3)+ch-'0';
		ch=getchar();
	}
	return x*f;
}
inline void write(const int x) {
	if(x>9)	write(x/10);
	putchar(x%10+'0');
}
inline char GetChar() {
	char ch=getchar();
	while(ch!='Q' && ch!='L')	ch=getchar();
	return ch;
}
const int Size=80005;
namespace UnionFindSet {

int father[Size],siz[Size];
inline void init(int n) {
	for(re i=1; i<=n; i++) {
		father[i]=i;
		siz[i]=1;
	}
}
int Find(int x) {
	if(x==father[x])	return x;
	return father[x]=Find(father[x]);
}

}
using namespace UnionFindSet;
const int Maxn=30000005;
int n,m,t,tot,maxn,v[Size],nv[Size],T[Size];
//树上主席树 
int ls[Maxn],rs[Maxn],sum[Maxn];
void update(int pre,int l,int r,int x,int &rt) {
	rt=++tot;
	ls[rt]=ls[pre];
	rs[rt]=rs[pre];
	sum[rt]=sum[pre]+1;
	if(l==r)	return;
	int mid=(l+r)>>1;
	if(x<=mid) {
		update(ls[pre],l,mid,x,ls[rt]);
	} else {
		update(rs[pre],mid+1,r,x,rs[rt]);
	}
}
int query(int l,int r,int u,int v,int lca,int flca,int k) {
	if(l==r)	return l;
	int mid=(l+r)>>1,num=sum[ls[u]]+sum[ls[v]]-sum[ls[lca]]-sum[ls[flca]];
	if(k<=num) {
		return query(l,mid,ls[u],ls[v],ls[lca],ls[flca],k);
	} else {
		return query(mid+1,r,rs[u],rs[v],rs[lca],rs[flca],k-num);
	}
}
int cnt,head[Size];
struct Edge {
	int v,next;
} w[Size<<1];
void AddEdge(int u,int v) {
	w[++cnt].v=v;
	w[cnt].next=head[u];
	head[u]=cnt;
}
int anc[Size][18],deep[Size];
void dfs(int x,int fa) {
	update(T[fa],1,maxn,v[x],T[x]);
	anc[x][0]=fa;
	deep[x]=deep[fa]+1;
	for(re i=1; i<=16; i++) {
		anc[x][i]=anc[anc[x][i-1]][i-1];
	}
	for(int i=head[x]; i; i=w[i].next) {
		int nxt=w[i].v;
		if(nxt!=fa) {
			dfs(nxt,x);
		}
	}
}
inline void merge(int u,int v) {
	//启发式合并，把小的树暴力重构，接到大的树上 
	int fu=Find(u);
	int fv=Find(v);
	if(siz[fu]<siz[fv]) {
		swap(u,v);
		swap(fu,fv);
	}
	AddEdge(u,v);
	AddEdge(v,u);
	dfs(v,u);
	siz[fu]+=siz[fv];
	father[fv]=fu;
}
inline int LCA(int u,int v) {
	if(deep[u]<deep[v])	swap(u,v);
	for(re i=16; i>=0; i--) {
		if(deep[anc[u][i]]>=deep[v]) {
			u=anc[u][i];
		}
	}
	if(u==v)	return u;
	for(re i=16; i>=0; i--) {
		if(anc[u][i]!=anc[v][i]) {
			u=anc[u][i];
			v=anc[v][i];
		}
	}
	return anc[u][0];
}
inline int Query(int x,int y,int k) {
	int lca=LCA(x,y);
	return query(1,maxn,T[x],T[y],T[lca],T[anc[lca][0]],k);
}
int main() {
//	freopen("testdata.in","r",stdin);
//	freopen("WA.txt","w",stdout);
	int testcase=read();
	n=read();
	m=read();
	t=read();
	init(n);
	for(re i=1; i<=n; i++) {
		nv[i]=v[i]=read();
		deep[i]=1;
	}
	sort(nv+1,nv+1+n);
	maxn=unique(nv+1,nv+1+n)-(nv+1);
	for(re i=1; i<=n; i++) {
		v[i]=lower_bound(nv+1,nv+1+maxn,v[i])-nv;
		update(T[i],1,maxn,v[i],T[i]);
	}
	for(re i=1; i<=m; i++) {
		int u=read();
		int v=read();
		merge(u,v);
	}
	int lastans=0;
	while(t--) {
		char ch=GetChar();
		int x=read()^lastans;
		int y=read()^lastans;
		if(ch=='Q') {
			int k=read()^lastans;
			write(lastans=nv[Query(x,y,k)]);
			putchar(10);
		} else {
			merge(x,y);
		}
	}
	return 0;
}
/*
1
4 2 1
412060525 42425138 926214957 762952138
2 4
3 2
Q 3 4 2
*/