代码随想录算法训练营第 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)
相关推荐
core51216 分钟前
SGD 算法详解：蒙眼下山的寻宝者
人工智能·算法·矩阵分解·sgd·目标函数
Ka1Yan23 分钟前
[链表] - 代码随想录 707. 设计链表
数据结构·算法·链表
scx2013100424 分钟前
20260112树状数组总结
数据结构·c++·算法·树状数组
FastMoMO29 分钟前
Qwen3-VL-2B 在 RK3576 上的部署实践：RKNN + RKLLM 全流程
算法
光算科技35 分钟前
AI重写工具导致‘文本湍流’特征｜如何人工消除算法识别标记
大数据·人工智能·算法
宵时待雨38 分钟前
数据结构（初阶）笔记归纳3:顺序表的应用
c语言·开发语言·数据结构·笔记·算法
智者知已应修善业41 分钟前
【C语言 dfs算法 十四届蓝桥杯 D飞机降落问题】2024-4-12
c语言·c++·经验分享·笔记·算法·蓝桥杯·深度优先
罗湖老棍子41 分钟前
最优乘车(travel)（信息学奥赛一本通- P1377）
算法·图论·bfs·最短路·字符串流·单向边
副露のmagic1 小时前
更弱智的算法学习 day36
学习·算法
core5121 小时前
SVD 算法详解：给数据做个“CT扫描”
算法·svd·图片压缩·目标函数
热门推荐
01GitHub 镜像站点02Linux下V2Ray安装配置指南03网站改了域名，如何查找？04Labelme从安装到标注：零基础完整指南05AI 规范驱动开发“三剑客”深度对比：Spec-Kit、Kiro 与 OpenSpec 实战指南06UV安装并设置国内源07安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）08Claude Code Skills 实用使用手册09百度网盘偷偷给电脑“降频”？10MC.JS：基于Web技术的网页版《我的世界》，免安装在线畅玩，支持存档