XSY1659 [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 的正整数，字母与数字以及两个数字之间用空格隔开。

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

HINT

对于 20%的数据 n≤1000,q≤1000

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

题目大意

给定一些点, 每个点有一个排名(也可以理解作权值), 有两种操作:

• 给定\(u\), \(v\)两个点, 合并这两个点所在的集合
• 询问\(u\)所在集合中权值第\(k\)小的点是哪个

Solution

• 思路1: 平衡树启发式合并. 时间复杂度: \(O(n \log^2 n)\)
• 思路2: 权值线段树合并. 时间复杂度: \(O(n \log n)\)

下面这份代码是线段树合并的.

注意空间要开的是\(n \log n + n\)

#include <cstdio>
#include <cctype>
#include <cstring>
#include <algorithm>

namespace Zeonfai
{
	inline int getInt()
	{
		int a = 0, sgn = 1;
		char c;

		while(! isdigit(c = getchar()))
			if(c == '-')
				sgn *= -1;

		while(isdigit(c))
			a = a * 10 + c - '0', c = getchar();

		return a * sgn;
	}

	inline char getChar()
	{
		char c;

		while(! isgraph(c = getchar()));

		return c;
	}

	void _print(int a)
	{
		if(! a)
			return;

		_print(a / 10);
		putchar(a % 10 + '0');
	}

	inline void println(int a)
	{
		if(a < 0)
			putchar('-'), a *= -1;

		if(! a)
			putchar(0);

		_print(a);
		putchar('\n');
	}
}

const int N = (int)1e5;
int n;

struct disjointSet
{
	int anc[N + 1];

	inline void initialize()
	{
		memset(anc, -1, sizeof(anc));
	}

	int access(int u)
	{
		return ~ anc[u] ? anc[u] = access(anc[u]) : u;
	}

	inline void link(int u, int pre)
	{
		anc[u] = pre;
	}
}st;

struct segmentTrees
{
	struct node
	{
		int suc[2], sz;
	}nd[N * 18];

	int rt[N + 1], tp;

	inline void initialize()
	{
		tp = 0;
		memset(rt, -1, sizeof(rt));
	}

	inline void newNode(int u)
	{
		nd[u].suc[0] = nd[u].suc[1] = -1, nd[u].sz = 0;
	}

	int _insert(int u, int L, int R, int pos)
	{
		if(! (~ u))
			newNode(u = tp ++);

		++ nd[u].sz;

		if(L == R)
			return u;

		int mid = L + R >> 1;

		if(pos <= mid)
			nd[u].suc[0] = _insert(nd[u].suc[0], L, mid, pos);
		else
			nd[u].suc[1] = _insert(nd[u].suc[1], mid + 1, R, pos);

		return u;
	}

	inline void insert(int a, int w)
	{
		rt[a] = _insert(rt[a], 1, n, w);
	}

	int _merge(int u, int _u)
	{
		if(! (~ u))
			return _u;

		if(! (~ _u))
			return u;

		nd[u].sz += nd[_u].sz;

		for(int i = 0; i < 2; ++ i)
			nd[u].suc[i] = _merge(nd[u].suc[i], nd[_u].suc[i]);

		return u;
	}

	inline void merge(int u, int v)
	{
		int setU = st.access(u), setV = st.access(v);

		if(setU == setV)
			return;

		if(nd[rt[setU]].sz < nd[rt[setV]].sz)
			std::swap(setU, setV);

		st.link(setV, setU);
		rt[setU] = _merge(rt[setU], rt[setV]);
		rt[setV] = -1;
	}

	int _query(int u, int L, int R, int k)
	{
		if(L == R)
			return L;

		int mid = L + R >> 1;

		if(~ nd[u].suc[0])
		{
			if(nd[nd[u].suc[0]].sz >= k)
				return _query(nd[u].suc[0], L, mid, k);
			else
				k -= nd[nd[u].suc[0]].sz;
		}

		return _query(nd[u].suc[1], mid + 1, R, k);
	}

	inline int query(int u, int k)
	{
		int setU = st.access(u);

		if(nd[rt[setU]].sz < k)
			return 0;

		return _query(rt[setU], 1, n, k);
	}
}trees;

int main()
{
	#ifndef ONLINE_JUDGE
	freopen("XSY1659.in", "r", stdin);
	freopen("XSY1659.out", "w", stdout);
	#endif

	using namespace Zeonfai;

	n = getInt();
	int m = getInt();
	st.initialize();
	trees.initialize();
	static int idx[N + 1];
	idx[0] = -1;

	for(int i = 1; i <= n; ++ i)
	{
		int rk = getInt();
		idx[rk] = i;
		trees.insert(i, rk);
	}

	for(int i = 0; i < m; ++ i)
	{
		int u = getInt(), v = getInt();
		trees.merge(u, v);
	}

	int q = getInt();

	for(int i = 0; i < q; ++ i)
	{
		char opt = getChar();
		int a = getInt(), b = getInt();

		if(opt == 'B')
			trees.merge(a, b);
		else if(opt == 'Q')
			println(idx[trees.query(a, b)]);
	}
}