53. 寻宝（Prim + Kruskal）
最小生成树------适用于建桥、修公路等问题
方法一 ：
Prim 算法，时间复杂度为 O(V^2)
适合稠密图，点少边多。
三部曲：
- 找非生成树距离生成树的最近节点。
- 加入生成树。
- 更新所有非生成树节点到生成树距离。
节点从 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)
适合稀疏图，点多边少。
- 对边进行排序
- 判断边两端节点在不在生成树（同一集合）里
- 不在------纳入生成树
- 在------不用这条边，否则会构成环
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));
}
}
}总结：
- 存图
- Prim 用邻接矩阵
- Kruskal 用朴素法
- 输出边
- Prim 用 int[] parent
- Kruskal 用 List<int[]>
- 适用场景
- Prim 适合稠密图
- Kruskal 适合稀疏图
- 时间复杂度
- Prim 为 O(V^2)
- Kruskal 为 O(E * logE)