题目描述
如题,一开始有 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 结点的距离小于任何结点,不过去掉也几乎不影响性能。
又到了博客推荐环节: