题面
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('
');
}
}
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)]);
}
}