代码随想录训练营第61天

今天感受到 Bellman_ford 算法系列在不同场景下的应用。 

建议依然是：一刷的时候，能理解 原理，知道Bellman_ford 解决不同场景的问题 ，照着代码随想录能抄下来代码就好，就算达标。 

二刷的时候自己尝试独立去写，三刷的时候 才能有一定深度理解各个最短路算法。

Bellman_ford 队列优化算法（又名SPFA）

import java.util.*;

class Edge {
    int to;  // 链接的节点
    int val; // 边的权重

    public Edge(int to, int val) {
        this.to = to;
        this.val = val;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt(); // 节点数
        int m = scanner.nextInt(); // 边数

        List<Edge>[] grid = new ArrayList[n + 1]; // 邻接表
        for (int i = 0; i < grid.length; i++) {
            grid[i] = new ArrayList<>();
        }

        // 将所有边保存起来
        for (int i = 0; i < m; i++) {
            int p1 = scanner.nextInt();
            int p2 = scanner.nextInt();
            int val = scanner.nextInt();
            grid[p1].add(new Edge(p2, val));
        }
        int start = 1;  // 起点
        int end = n;    // 终点

        int[] minDist = new int[n + 1];
        Arrays.fill(minDist, Integer.MAX_VALUE);
        minDist[start] = 0;

        Queue<Integer> que = new LinkedList<>();
        que.offer(start); // 队列里放入起点

        while (!que.isEmpty()) {
            int node = que.poll();

            for (Edge edge : grid[node]) {
                int to = edge.to;
                int value = edge.val;
                if (minDist[to] > minDist[node] + value) { // 开始松弛
                    minDist[to] = minDist[node] + value;
                    que.offer(to);
                }
            }
        }

        if (minDist[end] == Integer.MAX_VALUE) System.out.println("unconnected"); // 不能到达终点
        else System.out.println(minDist[end]); // 到达终点最短路径
    }
}

代码随想录

bellman_ford之判断负权回路

代码随想录

import java.util.Scanner;
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt(); // 顶点数
        int m = scanner.nextInt(); // 边数

        List<List<Integer>> grid = new ArrayList<>();

        for (int i = 0; i < m; i++) {
            int p1 = scanner.nextInt();
            int p2 = scanner.nextInt();
            int val = scanner.nextInt();
            // p1 指向 p2，权值为 val
            grid.add(new ArrayList<>(Arrays.asList(p1, p2, val)));
        }
        int start = 1;  // 起点
        int end = n;    // 终点

        int[] minDist = new int[n + 1];
        for (int i = 0; i <= n; i++) {
            minDist[i] = Integer.MAX_VALUE;
        }
        minDist[start] = 0;
        boolean flag = false;
        for (int i = 1; i <= n; i++) { // 这里我们松弛n次，最后一次判断负权回路
            for (List<Integer> side : grid) {
                int from = side.get(0);
                int to = side.get(1);
                int price = side.get(2);
                if (i < n) {
                    if (minDist[from] != Integer.MAX_VALUE && minDist[to] > minDist[from] + price) {
                        minDist[to] = minDist[from] + price;
                    }
                } else { // 多加一次松弛判断负权回路
                    if (minDist[from] != Integer.MAX_VALUE && minDist[to] > minDist[from] + price) {
                        flag = true;
                    }
                }
            }
        }

        if (flag) System.out.println("circle");
        else if (minDist[end] == Integer.MAX_VALUE) {
            System.out.println("unconnected");
        } else {
            System.out.println(minDist[end]);
        }
    }
}

bellman_ford之单源有限最短路

import java.util.Scanner;
import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt(); // 顶点数
        int m = scanner.nextInt(); // 边数
        int src = 0, dst = 0, k = 0;

        // 读取源点、终点和松弛步数k
        src = scanner.nextInt();
        dst = scanner.nextInt();
        k = scanner.nextInt();

        ArrayList<ArrayList<Integer>> grid = new ArrayList<>();

        for (int i = 0; i < m; i++) {
            int p1 = scanner.nextInt();
            int p2 = scanner.nextInt();
            int val = scanner.nextInt();
            // p1 指向 p2，权值为 val
            grid.add(new ArrayList<>(Arrays.asList(p1, p2, val)));
        }

        int[] minDist = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            minDist[i] = Integer.MAX_VALUE;
        }
        minDist[src] = 0;

        for (int i = 1; i <= k + 1; i++) { // 对所有边松弛 k + 1次
            boolean isUpdated = false;
            for (ArrayList<Integer> side : grid) {
                int from = side.get(0);
                int to = side.get(1);
                int price = side.get(2);
                if (minDist[from] != Integer.MAX_VALUE && minDist[to] > minDist[from] + price) {
                    minDist[to] = minDist[from] + price;
                    isUpdated = true;
                }
            }
            // 如果在第k步没有更新，说明不再有更短的路径
            if (!isUpdated && i == k) {
                break;
            }
            // 打印 minDist 数组
            for (int j = 1; j <= n; j++) {
                System.out.print(minDist[j] + " ");
            }
            System.out.println();
        }

        if (minDist[dst] == Integer.MAX_VALUE) {
            System.out.println("unreachable"); // 不能到达终点
        } else {
            System.out.println(minDist[dst]); // 到达终点最短路径
        }
    }
}

代码随想录