代码随想录算法训练营第 55 天 | 53. 寻宝（Prim + Kruskal）

Unstoppable222025-12-05 12:09

53. 寻宝（Prim + Kruskal）

题目链接

最小生成树------适用于建桥、修公路等问题

方法一 ：

Prim 算法，时间复杂度为 O(V^2)

适合稠密图，点少边多。

三部曲：

  1. 找非生成树距离生成树的最近节点。
  2. 加入生成树。
  3. 更新所有非生成树节点到生成树距离。

节点从 1 到 n。所以数组大小设置为 n + 1。

遍历 n - 1 次，因为每次循环找到了一条边，只要找到 n - 1 条边即可。

java 复制代码 
import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        int[][] graph = new int[n + 1][n + 1];

        for (int i = 0; i < n + 1; i++) { // 一开始节点全部未连接，全部赋值为最大值
            Arrays.fill(graph[i], Integer.MAX_VALUE);
        }

        for (int i = 0; i < k; i++) {
            int s = sc.nextInt();
            int t = sc.nextInt();
            int val = sc.nextInt();
            graph[s][t] = val;
            graph[t][s] = val; // 无向图要双向赋值
        }

        boolean[] isInTree = new boolean[n + 1]; // 该节点是否在生成树中
        int[] minDist = new int[n + 1]; // 非生成树节点到生成树的最小距离
        Arrays.fill(minDist, Integer.MAX_VALUE); // 距离初始化为最大值

        for (int i = 1; i < n; i++) { // 只需要遍历 n - 1 次 找出 n - 1 条边
            // 第一步：找非生成树节点到生成树距离最小的是哪个节点
            int minVal = Integer.MAX_VALUE; // 找数组的最小值
            int cur = 1; // 标记将被加入生成树的节点。第一次因为都是 Integer.MAX_VALUE，下方 cur 不会被赋值，所以 cur 从 1 开始
            for (int j = 1; j < n + 1; j++) {
                if (!isInTree[j] && minDist[j] < minVal) {
                    minVal = minDist[j];
                    cur = j;
                }
            }

            // 第二步：加入生成树
            isInTree[cur] = true;

            // 第三步：把 cur 节点加到生成树后，更新与它相连的非生成树节点到它的最小距离
            for (int j = 1; j < n + 1; j++) {
                if (!isInTree[j] && graph[cur][j] < minDist[j]) {
                    minDist[j] = graph[cur][j];
                }
            }
        }

        int result = 0;
        // 统计最小生成树总权值
        for (int i = 2; i < n + 1; i++) { // 从节点 2 开始，因为节点 1 的 minDist 还是 Integer.MAX_VALUE
            result += minDist[i];
        }

        System.out.println(result);
    }
}

拓展：输出最小生成树的每条边

可以用 HashMap 或一维数组 int[] parent。HashMap 适合节点编号非常大的情况。这里用一维数组。

不能用 List<int[]>，因为会添加很多次，需要覆盖之前的添加

java 复制代码 
import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        int[][] graph = new int[n + 1][n + 1];

        for (int i = 0; i < n + 1; i++) { // 一开始节点全部未连接，全部赋值为最大值
            Arrays.fill(graph[i], Integer.MAX_VALUE);
        }

        for (int i = 0; i < k; i++) {
            int s = sc.nextInt();
            int t = sc.nextInt();
            int val = sc.nextInt();
            graph[s][t] = val;
            graph[t][s] = val; // 无向图要双向赋值
        }

        boolean[] isInTree = new boolean[n + 1]; // 该节点是否在生成树中
        int[] minDist = new int[n + 1]; // 非生成树节点到生成树的最小距离
        Arrays.fill(minDist, Integer.MAX_VALUE); // 距离初始化为最大值

        int[] parent = new int[n + 1]; // 拓展：输出最小生成树的每条边

        for (int i = 1; i < n; i++) { // 只需要遍历 n - 1 次 找出 n - 1 条边
            // 第一步：找非生成树节点到生成树距离最小的是哪个节点
            int minVal = Integer.MAX_VALUE; // 找数组的最小值
            int cur = 1; // 标记将被加入生成树的节点。第一次因为都是 Integer.MAX_VALUE，下方 cur 不会被赋值，所以 cur 从 1 开始
            for (int j = 1; j < n + 1; j++) {
                if (!isInTree[j] && minDist[j] < minVal) {
                    minVal = minDist[j];
                    cur = j;
                }
            }

            // 第二步：加入生成树
            isInTree[cur] = true;

            // 第三步：把 cur 节点加到生成树后，更新与它相连的非生成树节点到它的最小距离
            for (int j = 1; j < n + 1; j++) {
                if (!isInTree[j] && graph[cur][j] < minDist[j]) {
                    minDist[j] = graph[cur][j];
                    parent[j] = cur; // 注意不能是 parent[cur] = j，否则会被反复覆盖
                }
            }
        }

        int result = 0;
        // 统计最小生成树总权值
        for (int i = 2; i < n + 1; i++) { // 从节点 2 开始，因为节点 1 的 minDist 还是 Integer.MAX_VALUE
            result += minDist[i];
        }

        System.out.println(result);

        // 拓展：输出最小生成树的每条边
        for (int i = 2; i < n + 1; i++) {
            System.out.println(i + "-" + parent[i]);
        }
    }
}

方法二：

Kruskal 算法，时间复杂度为 O(E * logE)

适合稀疏图，点多边少。

  1. 对边进行排序
  2. 判断边两端节点在不在生成树（同一集合）里
    • 不在------纳入生成树
    • 在------不用这条边，否则会构成环
java 复制代码 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

public class Main {
    static int N = 10005;
    static int[] father = new int[N];

    static {
        init();
    }

    static void init() {
        for (int i = 0; i < N; i++) {
            father[i] = i;
        }
    }

    static int find(int a) {
        return father[a] == a ? a : (father[a] = find(father[a]));
    }

    static void join(int a, int b) {
        father[find(a)] = find(b);
    }

    static boolean isSame(int a, int b) {
        return find(a) == find(b);
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        List<int[]> edges = new ArrayList<>(); // 采用朴素法，int[] 存 s、t、val

        for (int i = 0; i < k; i++) {
            int s = sc.nextInt();
            int t = sc.nextInt();
            int val = sc.nextInt();
            edges.add(new int[] {s, t, val});
        }

        // 第一步：对边进行排序
        edges.sort((a, b) -> a[2] - b[2]);

        int result = 0;
        int cnt = 0; // 统计已找出的边的个数

        // 第二步：判断边两端节点在不在同一集合里
        for (int[] edge : edges) {
            if (!isSame(edge[0], edge[1])) { // 不在同一集合里------加到生成树中
                join(edge[0], edge[1]);
                result += edge[2];

                cnt++;
                if (cnt == n - 1) { // 生成树共 n-1 条边，提前结束
                    break;
                }
            } // 在同一集合里------直接不用管
        }

        System.out.println(result);
    }
}

拓展：输出最小生成树的每条边

由于 Kruskal 算法直接是针对边进行遍历的。这里直接用 List<int[]> 来保存边。

不能用一维数组 int[] parent，因为可能会出现如下情况：1 同时连 2 和 3，会被覆盖

edge[0] = 1 edge[1] = 2

edge[0] = 1 edge[1] = 3

edge[0] = 2 edge[1] = 6

edge[0] = 3 edge[1] = 4

edge[0] = 4 edge[1] = 5

edge[0] = 5 edge[1] = 7

java 复制代码 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

public class Main {
    static int N = 10005;
    static int[] father = new int[N];

    static {
        init();
    }

    static void init() {
        for (int i = 0; i < N; i++) {
            father[i] = i;
        }
    }

    static int find(int a) {
        return father[a] == a ? a : (father[a] = find(father[a]));
    }

    static void join(int a, int b) {
        father[find(a)] = find(b);
    }

    static boolean isSame(int a, int b) {
        return find(a) == find(b);
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        List<int[]> edges = new ArrayList<>(); // 采用朴素法，int[] 存 s、t、val

        for (int i = 0; i < k; i++) {
            int s = sc.nextInt();
            int t = sc.nextInt();
            int val = sc.nextInt();
            edges.add(new int[] {s, t, val});
        }

        // 第一步：对边进行排序
        edges.sort((a, b) -> a[2] - b[2]);

        int result = 0;
        int cnt = 0; // 统计已找出的边的个数

        List<int[]> mstEdges = new ArrayList<>(); // 拓展：输出最小生成树的每条边

        // 第二步：判断边两端节点在不在同一集合里
        for (int[] edge : edges) {
            if (!isSame(edge[0], edge[1])) { // 不在同一集合里------加到生成树中
                join(edge[0], edge[1]);
                result += edge[2];

                mstEdges.add(edge); // 拓展：输出最小生成树的每条边

                cnt++;
                if (cnt == n - 1) { // 生成树共 n-1 条边，提前结束
                    break;
                }
            } // 在同一集合里------直接不用管
        }

        System.out.println(result);

        for (int[] mstEdge : mstEdges) { // 拓展：输出最小生成树的每条边
            System.out.println(Arrays.toString(mstEdge));
        }
    }
}

总结：

  1. 存图
    • Prim 用邻接矩阵
    • Kruskal 用朴素法
  2. 输出边
    • Prim 用 int[] parent
    • Kruskal 用 List<int[]>
  3. 适用场景
    • Prim 适合稠密图
    • Kruskal 适合稀疏图
  4. 时间复杂度
    • Prim 为 O(V^2)
    • Kruskal 为 O(E * logE)
相关推荐
橘颂TA1 小时前
【剑斩OFFER】算法的暴力美学——数青蛙
算法·leetcode·动态规划·结构与算法
m0_639397291 小时前
代码随想录算法训练营第三十九天｜198.打家劫舍，213.打家劫舍II，337.打家劫舍III
算法
heisd_11 小时前
KNN 算法和 K means算法和 Q-Learning 算法（简单的理解）
算法
liu****1 小时前
15.自定义类型：联合和枚举
数据结构·c++·剪枝
TL滕1 小时前
从0开始学算法——第六天（进阶排序算法）
笔记·学习·算法·排序算法
TL滕1 小时前
从0开始学算法——第六天（进阶排序算法练习）
笔记·python·学习·算法·排序算法
課代表2 小时前
正弦函数与椭圆的关系
数学·算法·几何·三角函数·椭圆·正弦·周长
zl_vslam2 小时前
SLAM中的非线性优-3D图优化之相对位姿Between Factor（七）
人工智能·算法·计算机视觉·3d
CoderYanger2 小时前
动态规划算法-简单多状态dp问题：12.打家劫舍Ⅱ
开发语言·算法·leetcode·职场和发展·动态规划·1024程序员节
热门推荐
01GitHub 镜像站点02【超详细教程】手把手教你从微软官网免费下载Windows 10官方原版ISO镜像（2025最新版）03React CVE-2025-55182漏洞排查与修复指南04UV安装并设置国内源05安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）06BongoCat - 跨平台键盘猫动画工具07本地部署阿里最新开源的Z-Image08Linux下V2Ray安装配置指南09智能库存管理的需求预测模型：从业务痛点到落地代码的完整实践10在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）