题解：AcWing 859 Kruskal算法求最小生成树

【题目来源】

AcWing：859 Kruskal算法求最小生成树 - AcWing题库

【题目描述】

给定一个 \(n\) 个点 \(m\) 条边的无向图，图中可能存在重边和自环，边权可能为负数。

求最小生成树的树边权重之和，如果最小生成树不存在则输出 impossible。

给定一张边带权的无向图 \(G=(V,E)\)，其中 \(V\) 表示图中点的集合，\(E\) 表示图中边的集合，\(n=|V|\)，\(m=|E|\)。

由 \(V\) 中的全部 \(n\) 个顶点和 \(E\) 中 \(n-1\) 条边构成的无向连通子图被称为 \(G\) 的一棵生成树，其中边的权值之和最小的生成树被称为无向图 \(G\) 的最小生成树。

【输入】

第一行包含两个整数 \(n\) 和 \(m\)。

接下来 \(m\) 行，每行包含三个整数 \(u,v,w\)，表示点 \(u\) 和点 \(v\) 之间存在一条权值为 \(w\) 的边。

【输出】

共一行，若存在最小生成树，则输出一个整数，表示最小生成树的树边权重之和，如果最小生成树不存在则输出 impossible。

【输入样例】

4 5
1 2 1
1 3 2
1 4 3
2 3 2
3 4 4

【输出样例】

6

【核心思想】

1. 问题分析：给定无向图 \(G=(V,E)\)，其中 \(|V|=n\)，\(|E|=m\)，边权可能为负数，图中可能存在重边和自环。需要求最小生成树的树边权重之和，若图不连通则输出 impossible。这是一个最小生成树（MST）问题，可以使用 Kruskal 算法求解。

2. 算法选择：

   • Kruskal 算法：基于贪心策略，按边权从小到大选择边，使用并查集维护连通性
   • 贪心策略：每次选择权值最小的边，若该边连接两个不同连通块则加入生成树
   • 并查集（Union-Find）：高效维护连通性，支持 \(O(\alpha(n))\) 的查找和合并操作
   • 边集数组存储：将所有边存储在数组中，按权值排序后依次处理

3. 关键步骤：

   • 初始化：
     • 读取 \(n\)（节点数）、\(m\)（边数）
     • 读入 \(m\) 条边 \((u, v, w)\)，存储到边集数组 \(edges[]\)
     • 对边集按权值从小到大排序：sort(edges+1, edges+m+1)
     • 并查集初始化：p[i] = i，每个节点的父节点指向自己
   • Kruskal 主循环（遍历排序后的边）：
     • 对于每条边 \(edges[i] = (u, v, w)\)：
       • 查找两个端点的根节点：s = find(u)，e = find(v)
       • 判断是否形成环：若 \(s == e\)，说明 \(u\) 和 \(v\) 已在同一连通块，跳过该边
       • 合并连通块：p[e] = s，将两个连通块合并
       • 累加答案：ans += w，将该边权值加入生成树总权重
       • 计数：cnt++，记录已选边数
   • 返回结果：
     • 若 \(cnt < n-1\)，说明图不连通，输出 impossible
     • 否则输出最小生成树总权重 \(ans\)

4. 时间/空间复杂度：

   • 时间复杂度：\(O(m \log m + m \cdot \alpha(n))\)，排序 \(O(m \log m)\)，并查集操作近似 \(O(1)\)
   • 空间复杂度：\(O(n + m)\)，并查集数组 \(O(n)\)，边集数组 \(O(m)\)
   • 适用于稀疏图（\(m\) 远小于 \(n^2\)），稠密图建议使用 Prim 算法

5. Kruskal 算法的核心思想：

   • 贪心策略：每次选择权值最小的边，保证局部最优达到全局最优
   • 割性质：对于任意割，最小权值的跨割边必然属于某棵最小生成树
   • 并查集维护连通性：高效判断两个节点是否连通，避免形成环
   • 边排序处理：按权值排序后依次处理，确保每次选当前最小边
   • 环检测：若边的两个端点已在同一连通块，则加入该边会形成环，必须跳过
   • 稀疏图优势：边数较少时，Kruskal 算法效率高于 Prim
   • 适用于稀疏图、边权排序后处理的场景

【解题思路】

【算法标签】

生成树

【代码详解】

#include <bits/stdc++.h>
using namespace std;
const int N=1e5+5, M=2e5+5, INF=1e9;
int n, m, ans, cnt;  //n点数量，m边数量，ans生成树边权和，cnt生成树边数量
int p[N];  //p[i]:点i的根节点
struct Edge {
    int u, v, cost;  //起点u，终点v顶点编号，cost，边v-u的权值
    bool operator < (const Edge &E) const {  //重载<操作符，按cost从小到大排序
        return cost < E.cost;
    }
}edges[M];

int find(int x)  //并查集查找顶点x的根节点
{
    if (p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
int main()
{
    cin >> n >> m;  //n点数量，m边数量
    for (int i=1; i<=m; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        if (u>v) swap(u, v);
        edges[i] = {u, v, w};
    }
    sort(edges+1, edges+m+1);  //边权值从小到大排序
    for (int i=1; i<=n; i++)
        p[i] = i;  //并查集初始化，根是它本身，p[x]指x的父节点编号

    for (int i=1; i<=m; i++) {  //从小到大查找边
        int s = edges[i].u, e = edges[i].v, w = edges[i].cost;
        s = find(s), e = find(e);  //查找边edges[i]的两个顶点u,v的根节点
        if (s!=e) {
            p[e] = s;  //集合合并，根节点相同
            ans += w;
            cnt++;
        }
    }
    if (cnt<n-1) puts("impossible");  //边数少于顶点数-1
    else cout << ans << endl;
    return 0;
}

【运行结果】

4 5
1 2 1
1 3 2
1 4 3
2 3 2
3 4 4
6