代码随想录算法训练营第59天

今天的建议依然是，一刷的时候，能了解 原理，照着代码随想录能抄下来代码就好，就算达标。 

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

dijkstra（堆优化版）精讲 

代码随想录

import java.util.*;

class Edge {
    int to;
    int val;

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

class MyComparison implements Comparator<Pair<Integer, Integer>> {
    @Override
    public int compare(Pair<Integer, Integer> lhs, Pair<Integer, Integer> rhs) {
        return Integer.compare(lhs.second, rhs.second);
    }
}

class Pair<U, V> {
    public final U first;
    public final V second;

    public Pair(U first, V second) {
        this.first = first;
        this.second = second;
    }
}

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<Edge>> grid = new ArrayList<>(n + 1);
        for (int i = 0; i <= n; i++) {
            grid.add(new ArrayList<>());
        }

        for (int i = 0; i < m; i++) {
            int p1 = scanner.nextInt();
            int p2 = scanner.nextInt();
            int val = scanner.nextInt();
            grid.get(p1).add(new Edge(p2, val));
        }

        int start = 1;
        int end = n;

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

        boolean[] visited = new boolean[n + 1];

        PriorityQueue<Pair<Integer, Integer>> pq = new PriorityQueue<>(new MyComparison());

        pq.add(new Pair<>(start, 0));

        minDist[start] = 0;

        while (!pq.isEmpty()) {
            Pair<Integer, Integer> cur = pq.poll();

            if (visited[cur.first]) continue;

            visited[cur.first] = true;

            for (Edge edge : grid.get(cur.first)) {
                if (!visited[edge.to] && minDist[cur.first] + edge.val < minDist[edge.to]) {
                    minDist[edge.to] = minDist[cur.first] + edge.val;
                    pq.add(new Pair<>(edge.to, minDist[edge.to]));
                }
            }
        }

        if (minDist[end] == Integer.MAX_VALUE) {
            System.out.println(-1);
        } else {
            System.out.println(minDist[end]);
        }
    }
}

Bellman_ford 算法精讲

代码随想录

import java.util.*;

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();
            grid.add(Arrays.asList(p1, p2, val));
        }

        int start = 1;  // 起点
        int end = n;    // 终点

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

        for (int i = 1; i < n; i++) { // 对所有边 松弛 n-1 次
            for (List<Integer> side : grid) { // 每一次松弛，都是对所有边进行松弛
                int from = side.get(0); // 边的出发点
                int to = side.get(1); // 边的到达点
                int price = side.get(2); // 边的权值
                // 松弛操作 
                // minDist[from] != Integer.MAX_VALUE 防止从未计算过的节点出发
                if (minDist[from] != Integer.MAX_VALUE && minDist[to] > minDist[from] + price) { 
                    minDist[to] = minDist[from] + price;  
                }
            }
        }

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