https://blog.csdn.net/niiick/article/details/81952126

https://www.cnblogs.com/ZegWe/p/6243883.html

Kruskal重构树—性质
1.是一个小/大根堆(由建树时边权的排序方式决定)
2.LCA(u,v)的权值是原图 u到v路径上最大/小边权的最小/大值(由建树时边权的排序方式决定)

Kruskal重构树—建树
模仿kruskal的过程
先将边权排序 (排序方式决定何种性质接下来说明)

依次遍历每条边
若改变连接的两个节点u和v 不在一个并查集内
就新建一个结点node
该点点权为这条边的边权

找到u，v所在并查集的根ui,vi u_i,v_iu
i

,v
i

连边(node,ui)(node,vi) (node,u_i)(node,v_i)(node,u
i

)(node,v
i

)
并更新并查集fa[ui]=node,fa[vi]=node fa[u_i]=node,fa[v_i]=nodefa[u
i

]=node,fa[v
i

]=node

遍历完原图所有边后
我们建出来的必定是一棵树
也就是我们要的kruskal重构树

注意这棵树是以最后新建的结点为根的有根树
若原图不连通，即建出的是一个森林
那么就遍历每个节点，找到其并查集的根作为其所在树的根

 1 void kruskal()
 2 {
 3 for(int i=1;i<=n;++i)ff[i]=i;
 4 sort(rem+1,rem+1+m,cmp);
 5 for(int i=1;i<=m;++i)
 6 {
 7 int fu=find(rem[i].u),fv=find(rem[i].v);
 8 if(fu!=fv)
 9 {
10 val[++cnt]=rem[i].dis;
11 ff[cnt]=ff[fu]=ff[fv]=cnt;
12 add(fu,cnt); add(cnt,fu);
13 add(fv,cnt); add(cnt,fv);
14 }
15 }
16 for(int i=1;i<=cnt;++i)
17 if(!vis[i])
18 {
19 int f=find(i);
20 dfs1(f,0); dfs2(f,f);
21 }
22 }

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;
}

View Code

若我们开始时将边权升序排序
且kruskal重构树是一个大根堆
因为边权大的边总是后加入，所以这点不难证明

反之若我们一开始将边权降序排序
且kruskal重构树是一个小根堆

这个性质最经典的应用就是
求从u出发只经过边权不超过x的边能到达的结点

我们只要在求出边权升序排序的kuaskal重构树
找到树上深度最小的，点权不超过x的结点(一般用树上倍增)
那么它子树内的所有节点就是上述所求
这里由其是大根堆的性质不难证明

一道挺毒瘤的练手题
BZOJ3551 [ONTAK2010]Peaks加强版【Kruskal重构树+主席树+树上倍增】题解

以及这次NOI2018的毒瘤
[NOI2018 D1T1]归程【Kruskal重构树】题解

——————————————————————————————————————————————————————————————

[bzoj 3732] Network (Kruskal重构树)

kruskal重构树

Description

给你N个点的无向图 (1 <= N <= 15,000)，记为：1…N。
图中有M条边 (1 <= M <= 30,000) ，第j条边的长度为： d_j ( 1 < = d_j < = 1,000,000,000).

现在有 K个询问 (1 < = K < = 15,000)。
每个询问的格式是：A B，表示询问从A点走到B点的所有路径中，最长的边最小值是多少？

Input

第一行： N, M, K。
第2..M+1行: 三个正整数：X, Y, and D (1 <= X <=N; 1 <= Y <= N). 表示X与Y之间有一条长度为D的边。
第M+2..M+K+1行: 每行两个整数A B,表示询问从A点走到B点的所有路径中，最长的边最小值是多少？

Output

对每个询问，输出最长的边最小值是多少。

Sample Input

6 6 8
1 2 5
2 3 4
3 4 3
1 4 8
2 5 7
4 6 2
1 2
1 3
1 4
2 3
2 4
5 1
6 2
6 1

Sample Output

5
5
5
4
4
7
4
5

Hint

1 <= N <= 15,000
1 <= M <= 30,000
1 <= d_j <= 1,000,000,000
1 <= K <= 15,000

Solution

首先如果这道题是可以离线的，那么我们可以将边从小到大排序，每次加边，然后把两个端点所在的联通块并在一起。那么当A，B刚好联通时加的那条边的边权就是答案。但是本题强制在线，所以我们必须先预处理再回答询问。
我们按照kruskal求最小生成树的方式加边，但每次在加边时，新建一个节点，然后把两个联通块（其实是两棵二叉树）的根节点作为其左右儿子，把边权赋值给新建节点。那么我们可以发现这棵树有几个性质。

是一棵二叉树（虽然这道题并没有什么卵用）；
满足父节点的值大于等于儿子节点，是一个大顶堆，这是最关键的一点；
原图上任意两点间路径最长边的最小值等于其lca的值；

这种建树的方法称作kruskal重构树。
那么A，B的lca就是所求答案。

Code

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;

const int maxn = 3e4 + 5; 
int n, m, q, cnt, x, y;
int fa[maxn << 1], f[maxn << 1][20], dep[maxn << 1], val[maxn << 1], ch[maxn << 1][2];

int find(int x) {return fa[x] == x ? x : fa[x] = find(fa[x]);}

struct edge {
    int u, v, w;
    bool operator < (const edge &a) const {return w < a.w;}
} e[maxn << 1];

inline int ask(int u, int v) {
    if(dep[u] < dep[v]) swap(u, v);
    int t = dep[u] - dep[v];
    for(int i = 0; i < 20; i++) if(t & (1<<i)) u = f[u][i];
    for(int i = 19; ~i; i--) {
        if(f[u][i] != f[v][i]) u = f[u][i], v = f[v][i];
    } 
    if(u != v) u = f[u][0];
    return u;
}

void dfs(int u) {
    if(!ch[u][0]) return;
    dep[ch[u][0]] = dep[ch[u][1]] = dep[u] + 1;
    dfs(ch[u][0]), dfs(ch[u][1]);
}

int main() {
    scanf("%d%d%d", &n, &m, &q), cnt = n;
    for(int i = 0; i < m; i++) scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
    sort(e, e + m);
    for(int i = 1; i < maxn; i++) fa[i] = i, fa[i + maxn] = i + maxn;
    for(int i = 0; i < m; i++) {
        int u = e[i].u, v = e[i].v;
        if(find(u) == find(v)) continue;
        ch[++cnt][0] = fa[u], ch[cnt][1] = fa[v];
        fa[fa[u]] = fa[fa[v]] = f[fa[u]][0] = f[fa[v]][0] = cnt;
        val[cnt] = e[i].w;
    }
    dfs(cnt);
    for(int j = 1; j < 20; j++) 
        for(int i = 1; i <= cnt; i++) f[i][j] = f[f[i][j-1]][j-1];
    for(int i = 0; i < q; i++) {
        scanf("%d%d", &x, &y);
        printf("%d\n",val[ask(x, y)]);
    }
    return 0;
}