[KamaCoder] 53. 寻宝（第七期模拟笔试）文章解释
题目描述
在世界的某个区域，有一些分散的神秘岛屿，每个岛屿上都有一种珍稀的资源或者宝藏。国王打算在这些岛屿上建公路，方便运输。
不同岛屿之间，路途距离不同，国王希望你可以规划建公路的方案，如何可以以最短的总公路距离将 所有岛屿联通起来（注意：这是一个无向图）。
给定一张地图，其中包括了所有的岛屿，以及它们之间的距离。以最小化公路建设长度，确保可以链接到所有岛屿。
输入描述
第一行包含两个整数V 和 E，V代表顶点数，E代表边数 。顶点编号是从1到V。例如：V=2，一个有两个顶点，分别是1和2。
接下来共有 E 行，每行三个整数 v1，v2 和 val，v1 和 v2 为边的起点和终点，val代表边的权值。
输出描述
输出联通所有岛屿的最小路径总距离
输入示例
7 11 1 2 1 1 3 1 1 5 2 2 6 1 2 4 2 2 3 2 3 4 1 4 5 1 5 6 2 5 7 1 6 7 1输出示例
数据范围：
62 <= V <= 10000;
1 <= E <= 100000;
0 <= val <= 10000;
[KamaCoder] 53. 寻宝 Prim 算法（第七期模拟笔试）
自己看到题目的第一想法
完全理解错了, 我以为是找到一条从节点 1 出发到节点 n , 路上要经过所有节点的路径最短的方案. 题目要求的是将所有城市连接在一起后, 要求建造的公路是的长度是最短的.
看完代码随想录之后的想法
对于希望节点连接在一起后, 节点连线的权值总和是最小的. 有两种方案, 一种是 prim 算法, 一种是 kruskal 算法.
对于 prim 算法, 就是从一个节点出发, 将该节点添加到最小生成树中, 同时更新与该节点相连的其他节点的距离. 因为节点默认是不和最小生成树相连的, 因此初始化时需要随意添加一个节点到最小生成树中, 该节点添加到进来后, 最小生成树就是该节点. 当有一个节点添加到最小生成树时, 与该节点相连的其他节点距离最小生成树的距离就是确定的了, 同时也不可能有其他更短的连接方式连接到该节点. 因此, 每次选择距离最小生成树最近的节点添加到最小生成树, 并更新完与该节点相邻的节点距离该生成树的距离后, 距离该最小生成树最近的节点也就知道了. 不停的往最小生成树中添加距离最近的节点, 直到添加 n - 1次后, 最小生成树将有 n 个节点, 所有节点就计算完成了.
import java.util.ArrayList;
import java.util.List;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
prim 算法
public class Main {
private static int[][] nodes = null;
private static int[] minDist = null;
private static boolean[] isInTree = null;
// 记录相连的边
// private static int[] parents = null;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int vertexCount = 0;
while (scanner.hasNext()) {
vertexCount = scanner.nextInt();
int sideCount = scanner.nextInt();
minDist = new int[vertexCount + 1];
nodes = new int[vertexCount + 1][vertexCount + 1];
// 记录相连的边
// parents = new int[vertexCount + 1];
isInTree = new boolean[vertexCount + 1];
for (int i = 0; i <= vertexCount; i++) {
minDist[i] = Integer.MAX_VALUE;
}
int fromNode;
int toNode;
int val;
for (int i = 0; i < sideCount; i++) {
fromNode = scanner.nextInt();
toNode = scanner.nextInt();
val = scanner.nextInt();
nodes[fromNode][toNode] = val;
nodes[toNode][fromNode] = val;
}
}
minDist[1] = 0;
for (int i = 0; i < vertexCount - 1; i++) {
int minDistIndex = 0;
for (int j = 1; j <= vertexCount; j++) {
if (!isInTree[j] && minDist[j] < Integer.MAX_VALUE && minDist[j] < minDist[minDistIndex]) {
minDistIndex = j;
}
}
isInTree[minDistIndex] = true;
for (int j = 1; j <= vertexCount; j++) {
if (nodes[minDistIndex][j] != 0 && !isInTree[j] && nodes[minDistIndex][j] < minDist[j]) {
minDist[j] = nodes[minDistIndex][j];
// 记录相连的边
// parents[j] = minDistIndex;
}
}
}
int result = 0;
for (int i = 1; i < minDist.length; i++) {
// 记录相连的边: 打印
// System.out.println(parents[i] + " -> " + i);
result += minDist[i];
}
System.out.println(result);
}
}自己实现过程中遇到哪些困难
1. 没想到只要添加 n - 1 个节点到最小生成树即可完成到所有节点最小路径的计算. 最开始采用的是记录一下最小生成树的节点数量, 当所有节点都添加到最小生成树后, 则停止.
2. 没有使用 boolean[] isInTree 来判断节点是否计算过, 而是使用 List<Integer> 来计算, 导致性能耗时
3. 最严重的是, 一开始完全理解错了 prim 算法的意图, 以为是想找到一条从节点 1 出发到 节点 n, 最短的路径. 实际上找的是连接所有节点后, 路劲最短的连接方式.
[KamaCoder] 53. 寻宝（第七期模拟笔试） 文章解释
题目描述
在世界的某个区域，有一些分散的神秘岛屿，每个岛屿上都有一种珍稀的资源或者宝藏。国王打算在这些岛屿上建公路，方便运输。
不同岛屿之间，路途距离不同，国王希望你可以规划建公路的方案，如何可以以最短的总公路距离将 所有岛屿联通起来（注意：这是一个无向图）。
给定一张地图，其中包括了所有的岛屿，以及它们之间的距离。以最小化公路建设长度，确保可以链接到所有岛屿。
输入描述
第一行包含两个整数V 和 E，V代表顶点数，E代表边数 。顶点编号是从1到V。例如：V=2，一个有两个顶点，分别是1和2。
接下来共有 E 行，每行三个整数 v1，v2 和 val，v1 和 v2 为边的起点和终点，val代表边的权值。
输出描述
输出联通所有岛屿的最小路径总距离
输入示例
7 11 1 2 1 1 3 1 1 5 2 2 6 1 2 4 2 2 3 2 3 4 1 4 5 1 5 6 2 5 7 1 6 7 1输出示例
6数据范围：
2 <= V <= 10000;
1 <= E <= 100000;
0 <= val <= 10000;
[KamaCoder] 53. 寻宝 Kruskal 算法（第七期模拟笔试）
自己看到题目的第一想法
无
看完代码随想录之后的想法
感觉 prim 和 kruskal 都让我有一点点似懂非懂的感觉. 特别是 kruskal 算法, 每次挑选权重更小的边, 如果产生了环路, 说明当前节点已经相连, 不需要继续添加. 非常合理, 又非常得过于符合直觉... 让我产生了一种, 不知道自己是不是真的懂了的感觉... 一般就是真的没有完全懂. 头疼.
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
//
public class Main {
// ====> 并查集部分 开始 <====
private static int[] father = null;
// ====> 并查集部分 结束 <====
// ====> Kruskal 部分 开始 <====
private static class Edge {
int from;
int to;
int val;
}
private static List<Edge> edges = new ArrayList<>();
// ====> Kruskal 部分 结束 <====
// 记录相连的边
// private static int[] parents = null;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
init(scanner.nextInt());
int sideCount = scanner.nextInt();
// 记录相连的边
// parents = new int[vertexCount + 1];
for (int i = 0; i < sideCount; i++) {
Edge edge = new Edge();
edge.from = scanner.nextInt();
edge.to = scanner.nextInt();
edge.val = scanner.nextInt();
edges.add(edge);
}
}
Collections.sort(edges, new Comparator<Edge>() {
@Override
public int compare(Edge edge1, Edge edge2) {
return edge1.val - edge2.val;
}
});
int result = 0;
for (Edge edge : edges) {
if (isSame(edge.from, edge.to)) {
continue;
}
join(edge.from, edge.to);
result += edge.val;
}
System.out.println(result);
}
// ====> 并查集部分 开始 <====
private static void init(int nodeCount) {
father = new int[nodeCount + 1];
for (int i = 0; i <= nodeCount; i++) {
father[i] = i;
}
}
private static boolean isSame(int u, int v) {
return find(u) == find(v);
}
private static int find(int u) {
if (u == father[u]) {
return u;
}
return father[u] = find(father[u]);
}
private static void join(int u, int v) {
u = find(u);
v = find(v);
if (u == v) {
return;
}
father[v] = u;
}
// ====> 并查集部分 结束 <====
}自己实现过程中遇到哪些困难
无, Kruskal 算法在测试用例里性能是高一些的, 取决于排序算法吧.
493
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
