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

原创 已于 2025-12-04 16:27:52 修改 · 152 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #数据结构 #图 #Prim #Kruskal

于 2025-12-04 16:20:29 首次发布

53. 寻宝（Prim + Kruskal）

题目链接

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

方法一：
Prim 算法，时间复杂度为 O(V^2)
适合稠密图，点少边多。

三部曲：

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

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

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

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[]>，因为会添加很多次，需要覆盖之前的添加

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. 判断边两端节点在不在生成树（同一集合）里
    • 不在——纳入生成树
    • 在——不用这条边，否则会构成环
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

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)
代码随想录算法PDF.zip
05-29
《代码随想录》是一本深受程序员喜爱的算法学习书籍，其PDF版本为读者提供了方便的电子阅读体验。这本书主要针对准备参加编程面试或者想要提升自己算法能力的开发者，通过实例解析和实战演练，帮助读者深入理解算法...
代码随想录算法PDF.rar
08-06
《代码随想录》是一本深受程序员喜爱的算法学习书籍，尤其对于初学者来说，它提供了深入浅出的讲解和实战演练。这本书的核心是通过实际编程来帮助读者理解和掌握算法，提升编程技能，特别是C++语言的应用。在C++这个...
代码随想录算法训练营第 57 天 |53.寻宝（最小生成树）
2301_79647020的博客
09-01 637
最小生成树
代码随想录算法训练营第六十一天| 53. 寻宝 Prim 算法、53. 寻宝 Kruskal 算法
07-09 813
3. 最严重的是, 一开始完全理解错了 prim 算法的意图, 以为是想找到一条从节点 1 出发到 节点 n, 最短的路径. 实际上找的是连接所有节点后, 路劲最短的连接方式.完全理解错了, 我以为是找到一条从节点 1 出发到节点 n , 路上要经过所有节点的路径最短的方案. 题目要求的是将所有城市连接在一起后, 要求建造的公路是的长度是最短的.不同岛屿之间，路途距离不同，国王希望你可以规划建公路的方案，如何可以以最短的总公路距离将 所有岛屿联通起来（注意：这是一个无向图）。顶点编号是从1到V。
代码随想录算法训练营第五十七天 | 53. 寻宝-kruskal算法
懒羊羊在努力的博客
09-13 1105
排序后的边顺序为[(1,2) (4,5) (1,3) (2,6) (3,4) (6,7) (5,7) (1,5) (3,2) (2,4) (5,6)]选边(1,2)，节点1 和 节点2 不在同一个集合，所以生成树可以添加边(1,2)，并将 节点1，节点2 放在同一个集合。选边(1,3)，节点1 和 节点3 不在同一个集合，生成树添加边(1,3)，并将节点1，节点3 放到同一个集合。选边(2,6)，节点2 和 节点6 不在同一个集合，生成树添加边(2,6)，并将节点2，节点6 放到同一个集合。
代码随想录算法训练营第五十七天 | 53. 寻宝-prim算法
懒羊羊在努力的博客
09-13 1221
如果是二维数组，来记录两个点链接，例如 parent[节点编号A][节点编号B] = 1 ，parent[节点编号B][节点编号A] = 1，来表示 节点A 与 节点B 相连，那就没有上面说的这个注意事项了，当然这么做的话，就是多开辟的内存空间。选取一个距离 最小生成树（节点1） 最近的非生成树里的节点，节点2，3，5 距离 最小生成树（节点1） 最近，选节点 2（其实选 节点3或者节点2都可以，距离一样的）加入最小生成树。parent[节点编号] = 节点编号， 这样就把一条边记录下来了。
代码随想录算法训练营第57天|卡码网 53. 寻宝 prim算法精讲和kruskal算法精讲
summersnowzgq的博客
09-17 477
prim算法 是从节点的角度 采用贪心的策略 每次寻找距离 最小生成树最近的节点 并加入到最小生成树中。prim算法核心就是三步：1.第一步，选距离最小生成树最近节点2.第二步，最近节点加入生成树3.第三步，更新非生成树节点到生成树的距离（即更新minDist数组）其中：minDist数组 用来记录 每一个节点距离最小生成树的最近距离。
代码随想录算法训练营第55天｜最小生成树：prim、kruskal算法
qq_32756029的博客
10-26 217
代码随想录算法训练营第55天｜最小生成树：prim、kruskal算法
代码随想录算法训练营第五十七天|53.寻宝
aaaaaaaaaaaaay的博客
10-03 142
思路：同样也是找最小生成树，kruskal的思路是先按照距离从小到大排序，然后将每个边的两个节点合成一个集合（使用并查集），遍历所有的边，如果两个节点已经属于同一个集合，那就不管了，否则就和为一个集合并将距离加入ans。思路：prim是用于构建最小生成树的，prim算法主要分为三步，首先找离最小生成树最近的节点，然后把这个节点加入最小生成树，之后把和这个节点直接相连的点的距离和原来存储最小距离相比较，看能否替代。53.寻宝kruskal。
代码随想录算法训练营第57天| prim算法精讲、kruskal算法精讲
2301_76253115的博客
02-27 253
接着下一个点找其与目前树最近的点 加入树中 连通与该结点最近的所有点 做路径长度初始化。最终所有点都进入的时候就是路径最短的结果。kruskal的思路是根据边长排序，判断边长两点是否在同一个集合，若已经在一个集合 则不做计算。prim思路是从点出发 构成树 连通与该结点最近的所有点 做路径长度初始化。
代码随想录算法训练营第五十七天 | prim算法和kruskal算法精讲 卡码网53.寻宝
m0_50413530的博客
04-24 523
根据minDist数组，选组距离生成树最近的节点加入生成树，那么minDist数组里记录的其实也是最小生成树的边的权值。最后我们就生成了一个最小生成树，绿色的边将所有节点链接到一起，并且保证权值是最小的，因为我们在更新minDist数组的时候，都是选距离最小生成树最近的点加入到树中。minDist数组用来记录每一个节点距离最小生成树的最近距离，来寻找距离最小生成树最近的节点，加入到最小生成树，刚开始还没有最小生成树，所以随便选一个节点加入就好。1、第一步：选距离生成树最近节点。1、用什么结构来记录。
Prim+Kruskal 算法求最小生成树.zip_c语言 算法
09-24
在提供的C语言代码文件"Prim+Kruskal 算法求最小生成树.c"中，应该包含了这两种算法的实现。通常，这些实现会包含以下部分： - 图的表示：可能使用邻接矩阵或邻接表来存储图的结构。 - Prim算法的实现：从一个顶点...
Prim与Kruskal算法的最小生成树matlab实现
05-26
在通信网理论作业3-最小生成树这个项目中，你可能会学习如何用MATLAB编写代码，实现Prim和Kruskal算法，并对给定的网络图数据进行最小生成树的构造。这将涉及到数据结构的设计、图的遍历以及最小生成树的验证等编程...
代码随想录的pdf版本，需要准备秋招的小伙伴们看过来呀！
02-28
《代码随想录》是一本深受程序员喜爱的书籍，尤其对于即将参加秋季招聘的计算机科学和技术专业的学生们来说，它是提升编程技能和算法能力的重要资源。这本书深入浅出地讲解了编程思维和各种常见算法，旨在帮助读者...
Leetcode 68 搜索插入位置 | 寻找比目标字母大的最小字母
im_AMBER的博客
12-04 699
你的错误逻辑正确逻辑找到 target 时返回 mid-1找到 target 时，继续向右查找（因为需要「大于」target 的最小字符）target <letters [mid] 时，mid 是候选，需保留，right=mid（左闭右开）或不立即排除 mid循环结束直接返回 letters [0]循环结束后，先判断 left 是否越界：越界则返回 letters [0]，否则返回 letters [left]初始right的取值与「越界判断」不匹配；
欧几里得距离算法-相似度
weixin_45609702的博客
12-04 27
本文介绍了一个计算欧几里得距离的Java方法。该方法接收两个Double数组作为输入，通过计算对应元素差值的平方和再开方，返回两个数组之间的欧几里得距离值。当输入数组长度不一致时，方法会返回0作为默认值。欧几里得距离算法常用于比较两个数组之间的相似度，是数据分析和机器学习中的基础距离度量方法。
dfs|mask^翻转
一个人知道自己为什么而活，他就能够接收任何一种生活
11-30 159
注意到：灯泡状态周期是6。
[优选算法专题十.哈希表 ——NO.55~57 两数之和、判定是否互为字符重排、存在重复元素]
2401_83386596的博客
12-03 554
两数之和问题的最优解法采用哈希表实现O(n)时间复杂度，通过存储元素值与下标的映射关系，快速查找互补值。字符重排判定问题通过单哈希数组统计字符出现次数，先加后减并实时校验，确保字符种类和数量完全一致。存在重复元素问题使用哈希集合检测重复元素，遍历数组时检查元素是否已存在于集合中。三种解法均利用哈希结构优化查找效率，将时间复杂度从暴力解法的O(n²)降至O(n)，是典型空间换时间策略的工业级实现。
【剑斩OFFER】算法的暴力美学——数青蛙
最新发布
就业知识博客
12-04 199
力扣1419题：数青蛙
基于Prim+Kruskal求解最小生成树问题
06-10
### Prim算法与Kruskal算法联合求解最小生成树的实现方法 Prim算法和Kruskal算法是两种经典的最小生成树（MST）求解方法。Prim算法适合稠密图，通过维护一个集合逐步扩展生成树；而Kruskal算法适合稀疏图，通过排序边并使用并查集避免环路来构造最小生成树。将这两种算法结合，可以通过以下方式实现： #### 算法思想 1. 使用Prim算法从某个顶点开始构建部分生成树，直到覆盖大部分顶点[^3]。 2. 在Prim算法完成后，利用剩余未处理的边进行Kruskal算法，确保所有顶点都被包含在最终的最小生成树中[^4]。 #### 实现步骤 以下是结合Prim算法和Kruskal算法的伪代码实现： ```python # Prim算法部分 def prim(graph, start_vertex): import heapq n = len(graph) visited = [False] * n min_heap = [(0, start_vertex)] # (weight, vertex) mst_edges = [] total_weight = 0 while min_heap: weight, u = heapq.heappop(min_heap) if visited[u]: continue visited[u] = True total_weight += weight for v, w in graph[u]: if not visited[v]: heapq.heappush(min_heap, (w, v)) mst_edges.append((u, v, w)) return mst_edges, total_weight, visited # Kruskal算法部分 def kruskal(graph, remaining_edges, visited): parent = list(range(len(graph))) rank = [0] * len(graph) def find_set(u): if parent[u] != u: parent[u] = find_set(parent[u]) return parent[u] def union_set(u, v): root_u = find_set(u) root_v = find_set(v) if root_u != root_v: if rank[root_u] > rank[root_v]: parent[root_v] = root_u elif rank[root_u] < rank[root_v]: parent[root_u] = root_v else: parent[root_v] = root_u rank[root_u] += 1 mst_edges = [] total_weight = 0 remaining_edges.sort(key=lambda x: x[2]) # Sort edges by weight for u, v, w in remaining_edges: if find_set(u) != find_set(v): union_set(u, v) mst_edges.append((u, v, w)) total_weight += w return mst_edges, total_weight # 联合算法 def combined_mst(graph, start_vertex): # Step 1: Use Prim to build a partial MST prim_edges, prim_weight, visited = prim(graph, start_vertex) # Step 2: Collect remaining edges for Kruskal remaining_edges = [] for u in range(len(graph)): for v, w in graph[u]: if not visited[u] or not visited[v]: remaining_edges.append((u, v, w)) # Step 3: Use Kruskal to complete the MST kruskal_edges, kruskal_weight = kruskal(graph, remaining_edges, visited) # Combine results total_mst_edges = prim_edges + kruskal_edges total_weight = prim_weight + kruskal_weight return total_mst_edges, total_weight ``` #### 结果解释 - `prim` 函数用于从指定起点开始构建部分最小生成树，并返回已访问的顶点集合。 - `kruskal` 函数接收剩余未处理的边，并通过并查集进一步扩展生成树。 - 最终结果为两部分生成树的合并，确保所有顶点都被包含在内[^1]。 #### 示例应用 假设输入图如下： ```python graph = [ [(1, 7), (2, 9), (5, 14)], [(0, 7), (2, 10), (3, 15)], [(0, 9), (1, 10), (3, 11), (5, 2)], [(1, 15), (2, 11), (4, 6)], [(3, 6), (5, 9)], [(0, 14), (2, 2), (4, 9)] ] start_vertex = 0 mst_edges, total_weight = combined_mst(graph, start_vertex) print("MST Edges:", mst_edges) print("Total Weight:", total_weight) ``` #### 注意事项 - Prim算法适用于稠密图，而Kruskal算法适用于稀疏图。因此，联合算法可以根据图的特性动态调整权重阈值[^2]。 - 在实际应用中，可能需要对输入图进行预处理以优化性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值