[KamaCoder] 47. 参加科学大会（第六期模拟笔试） dijkstra（堆优化版）
[KamaCoder] 47. 参加科学大会（第六期模拟笔试） dijkstra（堆优化版） 文章解释
题目描述
小明是一位科学家，他需要参加一场重要的国际科学大会，以展示自己的最新研究成果。
小明的起点是第一个车站，终点是最后一个车站。然而，途中的各个车站之间的道路状况、交通拥堵程度以及可能的自然因素（如天气变化）等不同，这些因素都会影响每条路径的通行时间。
小明希望能选择一条花费时间最少的路线，以确保他能够尽快到达目的地。
输入描述
第一行包含两个正整数，第一个正整数 N 表示一共有 N 个公共汽车站，第二个正整数 M 表示有 M 条公路。
接下来为 M 行，每行包括三个整数，S、E 和 V，代表了从 S 车站可以单向直达 E 车站，并且需要花费 V 单位的时间。
输出描述
输出一个整数，代表小明从起点到终点所花费的最小时间。当从起始车站不能到达终点车站时，则输出 -1。
输入示例
7 9 1 2 1 1 3 4 2 3 2 2 4 5 3 4 2 4 5 3 2 6 4 5 7 4 6 7 9输出示例
12数据范围：
1 <= N <= 500;
1 <= M <= 5000;
[KamaCoder] 47. 参加科学大会（第六期模拟笔试） dijkstra（堆优化版）
自己看到题目的第一想法
无
看完代码随想录之后的想法
一开始理解错了, 想着每次把“距离最小生成树最近的边挑选出来”添加到队列中. 提交后发现得到的结果会偏大.
dijkstra 优化算法的核心是, 之前需要通过 for 循环遍历 minDist 获取到未处理过的, 距离出发站点最近的节点. 如果我们将 minDist 中的元素添加到列表中, 每次都按值的大小排序, 这样每次获取栈顶元素即可, 得到的结果和循环遍历 minDist 后得到的结果是一致的. 同时因为是有向图, 并且无负权回路, 因此每次处理完一条边, 这条边就不会被再次处理到. 不会产生死循环.
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Scanner;
public class Main {
private static Map<Integer, List<Edge>> nodes = new HashMap<>();
private static int[] minDist = null;
private static boolean[] visited = null;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int nodeCount = 0;
while (scanner.hasNext()) {
nodeCount = scanner.nextInt();
int sideCount = scanner.nextInt();
minDist = new int[nodeCount + 1];
Arrays.fill(minDist, Integer.MAX_VALUE);
visited = new boolean[nodeCount + 1];
Edge edge = null;
for (int i = 0; i < sideCount; i++) {
edge = getEdge(scanner.nextInt(), scanner.nextInt(), scanner.nextInt());
List<Edge> toNodes = nodes.get(edge.from);
if (toNodes == null) {
toNodes = new ArrayList<>();
nodes.put(edge.from, toNodes);
}
toNodes.add(edge);
}
}
int start = 1;
minDist[start] = 0;
PriorityQueue<Edge> queue = new PriorityQueue(new Comparator<Edge>() {
@Override
public int compare(Edge edge1, Edge edge2) {
return edge1.value - edge2.value;
}
});
// 起点到起点的距离为0
Edge edge = getEdge(start, start, 0);
queue.add(edge);
while (!queue.isEmpty()) {
edge = queue.poll();
visited[edge.to] = true;
List<Edge> outEdges = nodes.get(edge.to);
if (outEdges == null) {
continue;
}
for (Edge outEdge : outEdges) {
// visited 是为了过滤节点已经在 queue 中,
// 但是节点距离出发车站更远的那些路径
if (visited[outEdge.to]
|| minDist[outEdge.from] + outEdge.value >= minDist[outEdge.to]) {
continue;
}
minDist[outEdge.to] = minDist[outEdge.from] + outEdge.value;
// 从起点到当前边的最短距离
queue.add(getEdge(start, outEdge.to, minDist[outEdge.to]));
}
}
if (minDist[nodeCount] == Integer.MAX_VALUE) {
System.out.println(-1);
} else {
System.out.println(minDist[nodeCount]);
}
}
private static Edge getEdge(int from, int to, int value) {
Edge edge = new Edge();
edge.from = from;
edge.to = to;
edge.value = value;
return edge;
}
private static class Edge {
int from;
int to;
int value;
}
}自己实现过程中遇到哪些困难
一开始添加到 queue 中的是获取到的离所有处理过节点最近的边, 然而应该是按该节点距离出发车站的距离排序.
[KamaCoder] 94. 城市间货物运输 I 文章解释
题目描述
某国为促进城市间经济交流，决定对货物运输提供补贴。共有 n 个编号为 1 到 n 的城市，通过道路网络连接，网络中的道路仅允许从某个城市单向通行到另一个城市，不能反向通行。
网络中的道路都有各自的运输成本和政府补贴，道路的权值计算方式为：运输成本 - 政府补贴。权值为正表示扣除了政府补贴后运输货物仍需支付的费用；权值为负则表示政府的补贴超过了支出的运输成本，实际表现为运输过程中还能赚取一定的收益。
请找出从城市 1 到城市 n 的所有可能路径中，综合政府补贴后的最低运输成本。如果最低运输成本是一个负数，它表示在遵循最优路径的情况下，运输过程中反而能够实现盈利。
城市 1 到城市 n 之间可能会出现没有路径的情况，同时保证道路网络中不存在任何负权回路。
输入描述
第一行包含两个正整数，第一个正整数 n 表示该国一共有 n 个城市，第二个整数 m 表示这些城市中共有 m 条道路。
接下来为 m 行，每行包括三个整数，s、t 和 v，表示 s 号城市运输货物到达 t 号城市，道路权值为 v （单向图）。
输出描述
如果能够从城市 1 到连通到城市 n， 请输出一个整数，表示运输成本。如果该整数是负数，则表示实现了盈利。如果从城市 1 没有路径可达城市 n，请输出 "unconnected"。
输入示例
6 7 5 6 -2 1 2 1 5 3 1 2 5 2 2 4 -3 4 6 4 1 3 5输出示例
1示例中最佳路径是从 1 -> 2 -> 5 -> 6，路上的权值分别为 1 2 -2，最终的最低运输成本为 1 + 2 + (-2) = 1。
示例 2：
4 2
1 2 -1
3 4 -1在此示例中，无法找到一条路径从 1 通往 4，所以此时应该输出 "unconnected"。
数据范围：
1 <= n <= 1000；
1 <= m <= 10000;-100 <= v <= 100;
[KamaCoder] 94. 城市间货物运输 I (Bellman_ford 算法)
自己看到题目的第一想法
无.
看完代码随想录之后的想法
每个节点与图中的其他节点连接的边的最大数量为 n - 1. 因此只要对所有节点舒展 n - 1 次, 就可以得到最终的结果.
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Scanner;
public class Main {
private static Map<Integer, List<Edge>> nodes = new HashMap<>();
private static int[] minDist = null;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int nodeCount = 0;
while (scanner.hasNext()) {
nodeCount = scanner.nextInt();
int sideCount = scanner.nextInt();
minDist = new int[nodeCount + 1];
Arrays.fill(minDist, Integer.MAX_VALUE);
Edge edge = null;
for (int i = 0; i < sideCount; i++) {
edge = new Edge();
edge.from = scanner.nextInt();
edge.to = scanner.nextInt();
edge.value = scanner.nextInt();
List<Edge> edges = nodes.get(edge.from);
if (edges == null) {
edges = new ArrayList<>();
nodes.put(edge.from, edges);
}
edges.add(edge);
}
}
minDist[1] = 0;
for (int i = 1; i < nodeCount; i++) {
for (Map.Entry<Integer, List<Edge>> entry : nodes.entrySet()) {
List<Edge> edges = entry.getValue();
if (edges == null) {
continue;
}
for (Edge edge : edges) {
// 没有连同的节点不要计算
if (minDist[edge.from] == Integer.MAX_VALUE
// 当前路径的代价没有更优, 放弃
|| minDist[edge.from] + edge.value >= minDist[edge.to]) {
continue;
}
minDist[edge.to] = minDist[edge.from] + edge.value;
}
}
}
if (minDist[nodeCount] == Integer.MAX_VALUE) {
System.out.println("unconnected");
} else {
System.out.println(minDist[nodeCount]);
}
}
private static class Edge {
int from;
int to;
int value;
}
}自己实现过程中遇到哪些困难
无.
475
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
