Merge pull request #2675 from learnerInTheFirstStage/master

youngyangyang04 · web-flow · commit 7ddc751c6bb6 · 2024-08-21T10:43:33.000+08:00
更新0094.城市间货物运输I.md Java版本解法
diff --git a/problems/kamacoder/0094.城市间货物运输I-SPFA.md b/problems/kamacoder/0094.城市间货物运输I-SPFA.md
@@ -352,6 +352,77 @@ SPFA（队列优化版Bellman_ford） 在理论上 时间复杂度更胜一筹
 ## 其他语言版本
 
 ### Java 
+```Java
+import java.util.*;
+
+public class Main {
+
+    // Define an inner class Edge
+    static class Edge {
+        int from;
+        int to;
+        int val;
+        public Edge(int from, int to, int val) {
+            this.from = from;
+            this.to = to;
+            this.val = val;
+        }
+    }
+
+    public static void main(String[] args) {
+        // Input processing
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int m = sc.nextInt();
+        List<List<Edge>> graph = new ArrayList<>();
+
+        for (int i = 0; i <= n; i++) {
+            graph.add(new ArrayList<>());
+        }
+
+        for (int i = 0; i < m; i++) {
+            int from = sc.nextInt();
+            int to = sc.nextInt();
+            int val = sc.nextInt();
+            graph.get(from).add(new Edge(from, to, val));
+        }
+
+        // Declare the minDist array to record the minimum distance form current node to the original node
+        int[] minDist = new int[n + 1];
+        Arrays.fill(minDist, Integer.MAX_VALUE);
+        minDist[1] = 0;
+
+        // Declare a queue to store the updated nodes instead of traversing all nodes each loop for more efficiency
+        Queue<Integer> queue = new LinkedList<>();
+        queue.offer(1);
+
+        // Declare a boolean array to record if the current node is in the queue to optimise the processing
+        boolean[] isInQueue = new boolean[n + 1];
+
+        while (!queue.isEmpty()) {
+            int curNode = queue.poll();
+            isInQueue[curNode] = false; // Represents the current node is not in the queue after being polled
+            for (Edge edge : graph.get(curNode)) {
+                if (minDist[edge.to] > minDist[edge.from] + edge.val) { // Start relaxing the edge
+                    minDist[edge.to] = minDist[edge.from] + edge.val;
+                    if (!isInQueue[edge.to]) { // Don't add the node if it's already in the queue
+                        queue.offer(edge.to);
+                        isInQueue[edge.to] = true;
+                    }
+                }
+            }
+        }
+        
+        // Outcome printing
+        if (minDist[n] == Integer.MAX_VALUE) {
+            System.out.println("unconnected");
+        } else {
+            System.out.println(minDist[n]);
+        }
+    }
+}
+
+```
 
 ### Python
 
diff --git a/problems/kamacoder/0094.城市间货物运输I.md b/problems/kamacoder/0094.城市间货物运输I.md
@@ -392,6 +392,63 @@ Bellman_ford 是可以计算 负权值的单源最短路算法。
 ## 其他语言版本
 
 ### Java 
+```Java
+public class Main {
+
+    // Define an inner class Edge
+    static class Edge {
+        int from;
+        int to;
+        int val;
+        public Edge(int from, int to, int val) {
+            this.from = from;
+            this.to = to;
+            this.val = val;
+        }
+    }
+
+    public static void main(String[] args) {
+        // Input processing
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int m = sc.nextInt();
+        List<Edge> edges = new ArrayList<>();
+
+        for (int i = 0; i < m; i++) {
+            int from = sc.nextInt();
+            int to = sc.nextInt();
+            int val = sc.nextInt();
+            edges.add(new Edge(from, to, val));
+        }
+
+        // Represents the minimum distance from the current node to the original node
+        int[] minDist = new int[n + 1];
+
+        // Initialize the minDist array
+        Arrays.fill(minDist, Integer.MAX_VALUE);
+        minDist[1] = 0;
+
+        // Starts the loop to relax all edges n - 1 times to update minDist array
+        for (int i = 1; i < n; i++) {
+
+            for (Edge edge : edges) {
+                // Updates the minDist array
+                if (minDist[edge.from] != Integer.MAX_VALUE && (minDist[edge.from] + edge.val) < minDist[edge.to]) {
+                    minDist[edge.to] = minDist[edge.from] + edge.val;
+                }
+            }
+        }
+
+        // Outcome printing
+        if (minDist[n] == Integer.MAX_VALUE) {
+            System.out.println("unconnected");
+        } else {
+            System.out.println(minDist[n]);
+        }
+    }
+}
+
+```
 
 ### Python
 
diff --git a/problems/kamacoder/0095.城市间货物运输II.md b/problems/kamacoder/0095.城市间货物运输II.md
@@ -244,6 +244,92 @@ int main() {
 ## 其他语言版本
 
 ### Java 
+```Java
+import java.util.*;
+
+public class Main {
+    // 基于Bellman_ford-SPFA方法
+    // Define an inner class Edge
+    static class Edge {
+        int from;
+        int to;
+        int val;
+        public Edge(int from, int to, int val) {
+            this.from = from;
+            this.to = to;
+            this.val = val;
+        }
+    }
+
+    public static void main(String[] args) {
+        // Input processing
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int m = sc.nextInt();
+        List<List<Edge>> graph = new ArrayList<>();
+
+        for (int i = 0; i <= n; i++) {
+            graph.add(new ArrayList<>());
+        }
+
+        for (int i = 0; i < m; i++) {
+            int from = sc.nextInt();
+            int to = sc.nextInt();
+            int val = sc.nextInt();
+            graph.get(from).add(new Edge(from, to, val));
+        }
+
+        // Declare the minDist array to record the minimum distance form current node to the original node
+        int[] minDist = new int[n + 1];
+        Arrays.fill(minDist, Integer.MAX_VALUE);
+        minDist[1] = 0;
+
+        // Declare a queue to store the updated nodes instead of traversing all nodes each loop for more efficiency
+        Queue<Integer> queue = new LinkedList<>();
+        queue.offer(1);
+
+        // Declare an array to record the times each node has been offered in the queue
+        int[] count = new int[n + 1];
+        count[1]++;
+
+        // Declare a boolean array to record if the current node is in the queue to optimise the processing
+        boolean[] isInQueue = new boolean[n + 1];
+
+        // Declare a boolean value to check if there is a negative weight loop inside the graph
+        boolean flag = false;
+
+        while (!queue.isEmpty()) {
+            int curNode = queue.poll();
+            isInQueue[curNode] = false; // Represents the current node is not in the queue after being polled
+            for (Edge edge : graph.get(curNode)) {
+                if (minDist[edge.to] > minDist[edge.from] + edge.val) { // Start relaxing the edge
+                    minDist[edge.to] = minDist[edge.from] + edge.val;
+                    if (!isInQueue[edge.to]) { // Don't add the node if it's already in the queue
+                        queue.offer(edge.to);
+                        count[edge.to]++;
+                        isInQueue[edge.to] = true;
+                    }
+
+                    if (count[edge.to] == n) { // If some node has been offered in the queue more than n-1 times
+                        flag = true;
+                        while (!queue.isEmpty()) queue.poll();
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (flag) {
+            System.out.println("circle");
+        } else if (minDist[n] == Integer.MAX_VALUE) {
+            System.out.println("unconnected");
+        } else {
+            System.out.println(minDist[n]);
+        }
+    }
+}
+
+```
 
 ### Python
 
diff --git a/problems/kamacoder/0096.城市间货物运输III.md b/problems/kamacoder/0096.城市间货物运输III.md
@@ -636,6 +636,71 @@ dijkstra 是贪心的思路 每一次搜索都只会找距离源点最近的非
 ## 其他语言版本
 
 ### Java 
+```Java
+import java.util.*;
+
+public class Main {
+    // 基于Bellman_for一般解法解决单源最短路径问题
+    // Define an inner class Edge
+    static class Edge {
+        int from;
+        int to;
+        int val;
+        public Edge(int from, int to, int val) {
+            this.from = from;
+            this.to = to;
+            this.val = val;
+        }
+    }
+
+    public static void main(String[] args) {
+        // Input processing
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int m = sc.nextInt();
+
+        List<Edge> graph = new ArrayList<>();
+
+        for (int i = 0; i < m; i++) {
+            int from = sc.nextInt();
+            int to = sc.nextInt();
+            int val = sc.nextInt();
+            graph.add(new Edge(from, to, val));
+        }
+
+        int src = sc.nextInt();
+        int dst = sc.nextInt();
+        int k = sc.nextInt();
+
+        int[] minDist = new int[n + 1];
+        int[] minDistCopy;
+
+        Arrays.fill(minDist, Integer.MAX_VALUE);
+        minDist[src] = 0;
+
+        for (int i = 0; i < k + 1; i++) { // Relax all edges k + 1 times
+            minDistCopy = Arrays.copyOf(minDist, n + 1);
+            for (Edge edge : graph) {
+                int from = edge.from;
+                int to = edge.to;
+                int val = edge.val;
+                // Use minDistCopy to calculate minDist
+                if (minDistCopy[from] != Integer.MAX_VALUE && minDist[to] > minDistCopy[from] + val) {
+                    minDist[to] = minDistCopy[from] + val;
+                }
+            }
+        }
+        
+        // Output printing
+        if (minDist[dst] == Integer.MAX_VALUE) {
+            System.out.println("unreachable");
+        } else {
+            System.out.println(minDist[dst]);
+        }
+    }
+}
+
+```
 
 ### Python
 
