[HNOI2012] 永无乡
洛谷题目链接:永无乡
题目描述
永无乡包含 \(n\) 座岛，编号从 \(1\) 到 \(n\) ，每座岛都有自己的独一无二的重要度，按照重要度可以将这 \(n\) 座岛排名，名次用 \(1\) 到 \(n\) 来表示。某些岛之间由巨大的桥连接，通过桥可以从一个岛到达另一个岛。如果从岛 \(a\) 出发经过若干座（含 \(0\) 座）桥可以 到达岛 \(b\) ，则称岛 \(a\) 和岛 \(b\) 是连通的。
现在有两种操作：
B x y 表示在岛 \(x\) 与岛 \(y\) 之间修建一座新桥。
Q x k 表示询问当前与岛 \(x\) 连通的所有岛中第 \(k\) 重要的是哪座岛，即所有与岛 \(x\) 连通的岛中重要度排名第 \(k\) 小的岛是哪座，请你输出那个岛的编号。
输入输出格式
输入格式：
第一行是用空格隔开的两个正整数 \(n\) 和 \(m\) ，分别表示岛的个数以及一开始存在的桥数。
接下来的一行是用空格隔开的 \(n\) 个数，依次描述从岛 \(1\) 到岛 \(n\) 的重要度排名。随后的 \(m\) 行每行是用空格隔开的两个正整数 \(a_i\) 和 \(b_i\) ，表示一开始就存在一座连接岛 \(a_i\) 和岛 \(b_i\) 的桥。
后面剩下的部分描述操作，该部分的第一行是一个正整数 \(q\) ，表示一共有 \(q\) 个操作，接下来的 \(q\) 行依次描述每个操作，操作的 格式如上所述，以大写字母 \(Q\) 或 \(B\) 开始，后面跟两个不超过 \(n\) 的正整数，字母与数字以及两个数字之间用空格隔开。
输出格式：
对于每个 Q x k 操作都要依次输出一行，其中包含一个整数，表示所询问岛屿的编号。如果该岛屿不存在，则输出 \(-1\) 。
输入输出样例
输入样例#1：
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
输出样例#1：
-1
2
5
1
2
说明
对于 20% 的数据 \(n \leq 1000, q \leq 1000\)
对于 100% 的数据 \(n \leq 100000, m \leq n, q \leq 300000\)
一句话题意: 给出一个有\(n\)个点的图,有连通和查询两种操作,每次可以连通两个块或者查询一个块内的第k小.
题解: 连通很显然是可以用并查集维护的,那么我们考虑如何查询第k小.这里我们需要一个方便维护的数据结构,可以使用splay+启发式合并来维护一个连通块.
什么是启发式合并?其实说简单点就是将一个元素个数少的并查集加入到另一个并查集中.
我们可以先构建\(n\)颗splay,用1 ~ n的编号表示1 ~ n 的splay的根(就和只有一颗splay时以0作为默认根是一个道理),以n+1 ~ n+n作为树中的元素,然后合并的时候就判断两个元素是否已经在同一个并查集中,如果不在,就把元素少的那一颗splay合并到另一颗splay上,每个点最多被合并logn次,所以这个复杂度是没问题的(虽然这里我也不清楚为什么是logn的) .
然后就是在模拟合并的时候变量搞清楚,就没什么问题了.
#include<bits/stdc++.h>
using namespace std;
const int N=500000+5;
int n, m, ask, w[N];
int cnt = 0, root[N], fa[N], pos[N];
//root[i]表示第i颗splay的根节点
struct splay{
int ch[2], fa, size, val;
}t[N];
int gi(){
int ans = 0, f = 1; char i = getchar();
while(i<'0'||i>'9'){if(i=='-')f=-1;i=getchar();}
while(i>='0'&&i<='9'){ans=ans*10+i-'0';i=getchar();}
return ans * f;
}
int find(int x){return x==fa[x] ? x : fa[x]=find(fa[x]);}
bool get(int x){return x == t[t[x].fa].ch[1];}
void up(int x){t[x].size = t[t[x].ch[0]].size+t[t[x].ch[1]].size+1;}
void rotate(int x){
int fa = t[x].fa, gfa = t[fa].fa, d1 = get(x), d2 = get(fa);
t[t[x].ch[d1^1]].fa = fa; t[fa].ch[d1] = t[x].ch[d1^1];
t[fa].fa = x; t[x].ch[d1^1] = fa;
t[x].fa = gfa; t[gfa].ch[d2] = x;
up(fa), up(x);
}
void splay(int x, int goal){
while(t[x].fa != goal){
int fa = t[x].fa, gfa = t[fa].fa;
int d1 = get(x), d2 = get(fa);
if(gfa != goal){
if(d1 == d2) rotate(fa);
else rotate(x);
}
rotate(x);
}
if(goal <= n) root[goal] = x;//goal属于1~n时是设置的根节点
}
void insert(int val, int rt){
int node = root[rt], fa = rt;
while(node && t[node].val != val)
fa = node, node = t[node].ch[t[node].val<val];
node = ++cnt;
if(fa > n) t[fa].ch[t[fa].val<val] = node;
t[node].fa = fa, t[node].val = val, t[node].size = 1;
splay(node, rt);
}
int kth(int rt, int k){
if(k > t[root[rt]].size) return -1;
int node = root[rt];
while(1){
int son = t[node].ch[0];
if(k <= t[son].size) node = son;
else if(k > t[son].size+1){
k -= t[son].size+1;
node = t[node].ch[1];
}
else return t[node].val;
}
}
void remove(int node, int to){
insert(t[node].val, to);
if(t[node].ch[0]) remove(t[node].ch[0], to);
if(t[node].ch[1]) remove(t[node].ch[1], to);
}
void merge(int x, int y){
int r1 = find(x), r2 = find(y);
if(r1 == r2) return;
if(t[root[r1]].size > t[root[r2]].size) swap(r1, r2);//r1 is smaller
fa[r1] = r2; remove(root[r1], r2);
}
int main(){
//freopen("data.in","r",stdin);
char opt; int x, y; n = gi(); m = gi(); cnt = n*2;
for(int i=1;i<=n;i++){
w[i] = gi(), fa[i] = i, root[i] = i+n;//以n+1~n+n作为splay的元素,一开始为根
pos[w[i]] = i; t[i+n].val = w[i];
t[i+n].size = 1; t[i+n].fa = i;
}
for(int i=1;i<=m;i++) x = gi(), y = gi(), merge(x, y);
ask = gi();
while(ask--){
cin >> opt; x = gi(); y = gi();
if(opt == 'B') merge(x, y);
else{
int temp = kth(find(x), y);
if(temp != -1) printf("%d\n", pos[temp]);
else printf("-1\n");
}
}
return 0;
}
