Kruskal重构树—性质
1.是一个小/大根堆(由建树时边权的排序方式决定)
2.LCA(u,v)的权值是 原图 u到v路径上最大/小边权的最小/大值(由建树时边权的排序方式决定)
Kruskal重构树—建树
模仿kruskal的过程,先将边权排序 (排序方式决定何种性质接下来说明)
依次遍历每条边
若该边连接的两个节点u和v 不在一个并查集内
就新建一个结点node
该点点权为这条边的边权
找到u,v所在并查集的根
u
i
,
v
i
u_i,v_i
ui,vi
连边
(
n
o
d
e
,
u
i
)
(
n
o
d
e
,
v
i
)
(node,u_i)(node,v_i)
(node,ui)(node,vi)
并更新并查集
f
a
[
u
i
]
=
n
o
d
e
,
f
a
[
v
i
]
=
n
o
d
e
fa[u_i]=node,fa[v_i]=node
fa[ui]=node,fa[vi]=node
遍历完原图所有边后
我们建出来的必定是一棵树
也就是我们要的kruskal重构树
注意这棵树是以最后新建的结点为根的有根树
若原图不连通,即建出的是一个森林
那么就遍历每个节点,找到其并查集的根作为其所在树的根
void kruskal()
{
for(int i=1;i<=n;++i)ff[i]=i;
sort(rem+1,rem+1+m,cmp);
for(int i=1;i<=m;++i)
{
int fu=find(rem[i].u),fv=find(rem[i].v);
if(fu!=fv)
{
val[++cnt]=rem[i].dis;
ff[cnt]=ff[fu]=ff[fv]=cnt;
add(fu,cnt); add(cnt,fu);
add(fv,cnt); add(cnt,fv);
}
}
for(int i=1;i<=cnt;++i)
if(!vis[i])
{
int f=find(i);
dfs1(f,0); dfs2(f,f);
}
}
Kruskal重构树—应用
若我们开始时将边权升序排序
则LCA(u,v)的权值代表 原图 u到v路径上最大边权的最小值
由于边权越大的结点深度越小
所以在这棵树上u到v的路径显然就是原图上u到v尽量沿着边权小的边走
而LCA(u,v)显然就是u到v路径上深度最小的结点
反之若我们一开始将边权降序排序
则LCA(u,v)的权值代表 原图 u到v路径上最小边权的最大值
证明类似
这是对Kruskal重构树性质最简单的应用
可以试着用这题练练手BZOJ3732 Network
#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;
int read()
{
int f=1,x=0;
char ss=getchar();
while(ss<'0'||ss>'9'){if(ss=='-')f=-1;ss=getchar();}
while(ss>='0'&&ss<='9'){x=x*10+ss-'0';ss=getchar();}
return f*x;
}
const int maxn=200010;
int n,m,q,cnt;
struct edge{int u,v,dis;}rem[maxn];
struct node{int v,nxt;}E[maxn];
int head[maxn],tot;
int ff[maxn],val[maxn];
int fa[maxn],top[maxn],vis[maxn];
int dep[maxn],son[maxn],size[maxn];
bool cmp(edge a,edge b){return a.dis<b.dis;}
void add(int u,int v)
{
E[++tot].nxt=head[u];
E[tot].v=v;
head[u]=tot;
}
int find(int x)
{
if(x==ff[x])return x;
else return ff[x]=find(ff[x]);
}
void dfs1(int u,int pa)
{
size[u]=1; vis[u]=1;
for(int i=head[u];i;i=E[i].nxt)
{
int v=E[i].v;
if(v==pa) continue;
dep[v]=dep[u]+1; fa[v]=u;
dfs1(v,u);
size[u]+=size[v];
if(size[v]>size[son[u]])son[u]=v;
}
}
void dfs2(int u,int tp)
{
top[u]=tp;
if(son[u]) dfs2(son[u],tp);
for(int i=head[u];i;i=E[i].nxt)
{
int v=E[i].v;
if(v==son[u]||v==fa[u]) continue;
dfs2(v,v);
}
}
void kruskal()
{
for(int i=1;i<=n;++i)ff[i]=i;
sort(rem+1,rem+1+m,cmp);
for(int i=1;i<=m;++i)
{
int fu=find(rem[i].u),fv=find(rem[i].v);
if(fu!=fv)
{
val[++cnt]=rem[i].dis;
ff[cnt]=ff[fu]=ff[fv]=cnt;
add(fu,cnt); add(cnt,fu);
add(fv,cnt); add(cnt,fv);
}
}
dfs1(cnt,0); dfs2(cnt,cnt);
}
int LCA(int u,int v)
{
while(top[u]!=top[v])
{
if(dep[top[u]]>dep[top[v]]) u=fa[top[u]];
else v=fa[top[v]];
}
if(dep[u]<dep[v])return u;
else return v;
}
int main()
{
n=read();m=read();q=read();cnt=n;
for(int i=1;i<=m;++i)
rem[i].u=read(),rem[i].v=read(),rem[i].dis=read();
kruskal();
while(q--)
{
int u=read(),v=read();
printf("%d\n",val[LCA(u,v)]);
}
return 0;
}
若我们开始时将边权升序排序
且kruskal重构树是一个大根堆
因为边权大的边总是后加入,所以这点不难证明
反之若我们一开始将边权降序排序
且kruskal重构树是一个小根堆
这个性质最经典的应用就是
求从u出发只经过边权不超过x的边能到达的结点
我们只要在求出边权升序排序的kuaskal重构树
找到树上深度最小的,点权不超过x的结点(一般用树上倍增)
那么它子树内的所有节点就是上述所求
这里由其是大根堆的性质不难证明
一道挺毒瘤的练手题
BZOJ3551 [ONTAK2010]Peaks加强版【Kruskal重构树+主席树+树上倍增】题解
以及这次NOI2018的毒瘤
[NOI2018 D1T1]归程【Kruskal重构树】题解