LeetCode刷题--- Dijkstra 求最短路径

首先是图的表示，邻接矩阵和邻接表。实现看代码

• 邻接矩阵：二维数组，
  • matrix[a][b] 表示 从a可以指向b
  • 无向图而言， matrix[a][b]=matrix[b][a]，比如可以定义matrix[a][b]=1表示ab是连接的，matrix[a][b]=0表示ab是不可连接的
  • 有向图：matrix[a][b]=x，表示从a到b的权是x，如果matrix[a][b]=无穷大，表示ab是不可连接的
• 邻接表：
  • 外层是一个数组，数组长度表示图中有多少个节点，数组下标对应节点a
  • 每个数组中，存放一个链表，链表的每个节点也是数组
    • 链表长度代表从a可以直接指向多少个节点
    • 链表元素树一个数组，数组第一个元素代表被执向的b，第二个元素代表a到b的权

个人感觉，邻接矩阵适合无向图，邻接表适合有向图。

/**
 * 邻接矩阵
 *
 * @param n 初始化图中节点的个数
 * @param edges edges边，从edge[0]指向edge[1],路径长度为edge[2]
 * @return matrix
 */
public int[][] adjacentMatrix(int n, int[][] edges) {
    // 邻接矩阵就是一个二维数组，很好理解，对应坐标的值是路径长度
    int[][] matrix = new int[n][n];

    for (int[] edge : edges) {
        int start = edge[0];
        int end = edge[1];
        int length = edge[2];
        matrix[start][end] = length;
    }
    return matrix;
}

public List<int[]>[] adjacentList(int n, int[][] edges) {
    // 邻接列表，最外层是个数组，数组元素是一个列表
    // 列表中存储的数据，又是一个数组
    // 最外层数组，坐标代表edge[0]
    // 数组元素是个列表，这个列表存储的东西是 edge[1]，edge[2]
    // 每个链表有多少元素，就说明这个点指向多少个别的点
    List<int[]>[] list = new List[n];
    for (int i = 0; i < n; i++) {
        list[i] = new ArrayList<>();
    }

    for (int[] edge : edges) {
        int start = edge[0];
        int end = edge[1];
        int length = edge[2];
        list[start].add(new int[] {end, length});
    }
    return list;
}

 2642. 设计可以求最短路径的图类

比如我们求从0 到其他点的最短距离，定义一个数组，第0行分别是每个节点，第一行是0到其他节点的距离，初始化为正无穷大，第三行是表示是否已经是最小距离。

0	1	2	3
0	∞	∞	∞
T	F	F	F

 首先遍历0能够直接到达的顶点，修改如下，此时0到1的距离是最短的，可以标记为T

0	1	2	3
0	2	5	∞
T	T	F	F

然后看从2出发，能够直接到达的距离

因为从1到2的距离是2+1，小于当前的5，因此可以刷新下表，此时得到了0到2最短距离3

0	1	2	3
0	2	3	∞
T	T	T	F

思路就是上面的思路，不断的获取距离，然后和当前的距离比较，如果比他小，就更新进去。

public class Graph {

    List<int[]>[] graph;

    public Graph(int n, int[][] edges) {
        graph = adjacentList(n, edges);
    }

    public List<int[]>[] adjacentList(int n, int[][] edges) {
        List<int[]>[] list = new List[n];
        for (int i = 0; i < n; i++) {
            list[i] = new ArrayList<>();
        }

        for (int[] edge : edges) {
            int start = edge[0];
            int end = edge[1];
            int length = edge[2];
            list[start].add(new int[] {end, length});
        }
        return list;
    }

    // 向边集中添加一条边,本题的数据保证添加这条边之前对应的两个节点之间没有有向边
    // 这说明添加不会产生新的节点。即邻接矩阵外层的数组长度不会改变，只会改变数组元素的链表
    public void addEdge(int[] edge) {
        int start = edge[0];
        int end = edge[1];
        int length = edge[2];
        graph[start].add(new int[] {end, length});
    }

    public int shortestPath(int node1, int node2) {
        // 如果是同一个端点，说明路径为0，直接返回即可
        if (node1 == node2) {
            return 0;
        }

        // 定义一个距离数组，用于标识从当前node1出发，到所有点的最短路径，初始化值为Integer.MAX_VALUE，表示无穷大
        int[] distance = new int[graph.length];
        Arrays.fill(distance, Integer.MAX_VALUE);
        // node1到自身的距离为0；
        distance[node1] = 0;

        // 参考BFS，定义一个队列
        Queue<int[]> queue = new LinkedList<>();
        // 把node1变成节点传入队列中，队列存一个长度2的数组，分别表示到这个节点，距离
        queue.offer(new int[] {node1, 0});
        while (!queue.isEmpty()) {
            int[] poll = queue.poll();
            int cur = poll[0];
            int cost = poll[1];

            // if (cur == node2) {
            //     return cost;
            // }

            // 从邻接列表中取出当前节点可以指向的节点list，遍历这个list
            List<int[]> list = graph[cur];
            for (int[] arr : list) {
                int next = arr[0];
                int ncost = arr[1];
                // 如果路径和比当前小，就更新进去
                if (distance[next] > cost + ncost) {
                    distance[next] = cost + ncost;
                    queue.offer(new int[] {next, cost + ncost});
                }
            }
        }

        return distance[node2] == Integer.MAX_VALUE ? -1 : distance[node2];
    }
}

// 优化，如果我们定义一个优先级队列，这样每次BFS的时候，都会先遍历路径最小的节点
// 这样的话，就可以在while循环里面进行判断，如果等于目标节点，就可以直接返回了
Queue<int[]> queue = new PriorityQueue<>((a, b) -> a[1] - b[1]);