题目描述
如题，一开始有 n n n 个小根堆，每个堆包含且仅包含一个数。接下来需要支持两种操作：
1 x y 1~ x~ y 1 x y：将第 x x x 个数和第 y y y 个数所在的小根堆合并（若第 x x x 或第 y y y 个数已经被删除或第 x x x 和第 y y y 个数在用一个堆内，则无视此操作）。
2 x 2~ x 2 x：输出第 x x x 个数所在的堆最小数，并将这个最小数删除（若有多个最小数，优先删除先输入的；若第 x x x 个数已经被删除，则输出 − 1 -1 −1 并无视删除操作）。
输入格式
第一行包含两个正整数 n , m n, m n,m 分别表示一开始小根堆的个数和接下来操作的个数。
第二行包含 n n n 个正整数，其中第 i i i 个正整数表示第 i i i 个小根堆初始时包含且仅包含的数。
接下来 m m m 行每行 2 2 2 个或 3 3 3 个正整数，表示一条操作，格式如下：
操作 1 1 1： 1 x y 1~ x~ y 1 x y
操作 2 2 2： 2 x 2~ x 2 x
输出格式
输出包含若干行整数，分别依次对应每一个操作 2 2 2 所得的结果。
输入
5 5
1 5 4 2 3
1 1 5
1 2 5
2 2
1 4 2
2 2
输出
1
2
【数据规模】
对于
30
%
30\%
30% 的数据：
n
≤
10
n\le 10
n≤10，
m
≤
10
m\le 10
m≤10。
对于
70
%
70\%
70% 的数据：
n
≤
1
0
3
n\le 10^3
n≤103 ，
m
≤
1
0
3
m\le 10^3
m≤103 。
对于
100
%
100\%
100% 的数据：
n
≤
1
0
5
n\le 10^5
n≤105 ，
m
≤
1
0
5
m\le 10^5
m≤105
初始时小根堆中的所有数都在
i
n
t
int
int 范围内。
【样例解释】
初始状态下，五个小根堆分别为： { 1 } \{1\} {1}、 { 5 } \{5\} {5}、 { 4 } \{4\} {4}、 { 2 } \{2\} {2}、 { 3 } \{3\} {3}。
第一次操作，将第 1 1 1 个数所在的小根堆与第 5 5 5 个数所在的小根堆合并，故变为四个小根堆： { 1 , 3 } \{1,3\} {1,3}、 { 5 } \{5\} {5}、 { 4 } \{4\} {4}、 { 2 } \{2\} {2}。
第二次操作，将第 2 2 2 个数所在的小根堆与第 5 5 5 个数所在的小根堆合并，故变为三个小根堆： { 1 , 3 , 5 } \{1,3,5\} {1,3,5}、 { 4 } \{4\} {4}、 { 2 } \{2\} {2}。
第三次操作，将第 2 2 2 个数所在的小根堆的最小值输出并删除，故输出 1 1 1，第一个数被删除，三个小根堆为： { 3 , 5 } \{3,5\} {3,5}、 { 4 } \{4\} {4}、 { 2 } \{2\} {2}。
第四次操作，将第 4 4 4 个数所在的小根堆与第 2 2 2 个数所在的小根堆合并，故变为两个小根堆： { 2 , 3 , 5 } \{2,3,5\} {2,3,5}、 { 4 } \{4\} {4}。
第五次操作，将第 2 2 2 个数所在的小根堆的最小值输出并删除，故输出 2 2 2，第四个数被删除，两个小根堆为： { 3 , 5 } \{3,5\} {3,5}、 { 4 } \{4\} {4}。
故输出依次为 1 1 1、 2 2 2。
思路
需要使用一种能够动态维护最值，并且支持合并的数据结构，于是选择了左偏树。
先放代码，再说细节：
#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
int ls[N],rs[N],rt[N],v[N],id[N],d[N],vis[N];
int n,m,op,x,y;
int merge(int x,int y){
if(!x||!y) return x+y;
if(v[y]<v[x]||(v[y]==v[x]&&id[y]<id[x])) swap(x,y);
rs[x]=merge(rs[x],y);
if(d[ls[x]]<d[rs[x]]) swap(ls[x],rs[x]);
d[x]=d[rs[x]]+1;
return x;
}
int get(int x){
if(rt[x]==x) return x;
return rt[x]=get(rt[x]);
}
int main(){
cin>>n>>m;
d[0]=-1;
for(int i=1;i<=n;i++)
cin>>v[i],id[i]=rt[i]=i;
while(m--){
cin>>op>>x;
if(op==1){
cin>>y;
if(vis[x]||vis[y]) continue;
x=get(x),y=get(y);
if(x!=y) rt[x]=rt[y]=merge(x,y);
}else if(op==2){
if(vis[x]){ cout<<"-1\n"; continue; }
x=get(x);
cout<<v[x]<<"\n";
vis[x]=1;
rt[ls[x]]=rt[rs[x]]=rt[x]=merge(ls[x],rs[x]);
}
}
}
这题还需要查询某个结点所在的根节点，可以再多维护一个
f
a
fa
fa 关系。但是，左偏树不会保证平衡，若是一层一层往上找根节点，复杂度没有保证。
所以用并查集压缩路径的方法维护根节点。
rt[ls[x]]=rt[rs[x]]=rt[x]=merge(ls[x],rs[x]);
这行代码绝对不能写成：rt[ls[x]]=rt[rs[x]]=merge(ls[x],rs[x]);
因为压缩路径后，x为根的子树中，很多结点的根节点直接指向x，第二种写法只修改了它左右儿子的根节点，显然是错的。
如果要一个个去修改子树结点的根，也太慢了，所以 rt[x]=merge(ls[x],rs[x]) 继续交给并查集去处理。
if(!x||!y) return x+y;
这个相当于：if(!x) return y; if(!y) return x;
d[0]=-1;
这行代码让
n
u
l
l
null
null 结点的距离小于任何结点，不过去掉也几乎不影响性能。
又到了博客推荐环节：