Dijkstra算法的应用-leetcode 743：网络延迟时间

leetcode743：网络延迟时间

题目意在求：从某个节点开始，找到该点到其他各点的最短路径，并取所有的最短路径中的最大值作为结果输出。

以下面的例子看Dijkstra算法如何从 *** 作：

                                                           

我们借助一个优先级队列和一个数组，优先级队里记录当前待访问的节点以及距离，数组记录每个节点最短路径上的parent节点。

节点	A	B	C	D	E
parent	~	A	B	B	C

具体分析过程如下（字好差......）：该过程适用于有向图和无向图

该过程我们能够知道起始点到每个点的最短路径，到A最短是0，到B最短是2，到C最短是3，到D最短是5，到E最短是4。

我们怎么用代码实现这个过程呢？

下面这个过程呢，与上面无关，（因为上面这种方法可能涉及到存point对象（一个点，一个父点）），本题要求只用求最短距离即可，没有让我们把最短距离回溯出来，所以我们简化一下。

首先我们肯定时需要先存邻接矩阵的，在构造邻接矩阵的时候：初始化对角线元素为0（自己到自己的距离为0），初始化其他各个点之间的距离为无穷大

dijkstra过程：

我们需要一个visited数组来标记某个点是否被访问过，一个dist数组来记录每个点当前的最短距离

因为有n个节点，我们需要迭代n次，每次都去找没有被访问过，且距离最小的点作为本次的起始点，然后访问该点，更新与该点有连接的所有的点的距离，整个代码实现过程如下：

import java.util.*;

/**
 * @Author
 * @Date 2022/6/1 19:07
 * @Version 1.0
 * @Description
 **/
class Test {
    public static void main(String[] args) {
        int[][] times = new int[][]{
                {1, 2, 1}, {2, 3, 7}, {1, 3, 4}, {2, 1, 2}
        };
        new Test().networkDelayTime(times, 4, 1);
    }


    int[][] adj; // 存储邻接矩阵
    public int networkDelayTime(int[][] times, int n, int k) {
        // 1、构造邻接矩阵
        adj = new int[n + 1][n + 1];
        for (int i = 0; i < adj.length; i++) {
            for (int j = 0; j < adj.length; j++) {
                adj[i][j] = i == j ? 0 : Integer.MAX_VALUE; // 初始化对角线值为0即自己到自己的距离是0，到其他点的距离是无穷大
            }
        }
        for (int i = 0; i < times.length; i++) {// 遍历times矩阵，构建邻接矩阵
            int s = times[i][0];
            int e = times[i][1];
            int d = times[i][2];
            adj[s][e] = d;
        }
        // 最短路，n是定点个数u，k是其实点
        dijkstra(n, k);

        int max = 0;
        for (int i = 1; i <= n; i++) {
            max = Math.max(max, dist[i]);
        }
        return max >= Integer.MAX_VALUE ? -1 : max;
    }

    boolean[] vis;
    int[] dist;

    void dijkstra(int n, int k) {
        vis = new boolean[n + 1]; // 用于标记哪些点被访问过
        dist = new int[n + 1]; // 用于标记起始点到每个点的最短路径
        Arrays.fill(vis, false);
        Arrays.fill(dist, Integer.MAX_VALUE);

        dist[k] = 0; // 其实点到自己的距离为0

        for (int i = 1; i <= n; i++) { // 因为有n个点，所以我们迭代n次
            int t = -1; // 当前要访问的节点（当然是找没有访问过，而且距离最小的那个点）
            for (int p = 1; p <= n; p++) {
                if (!vis[p] && (t == -1 || dist[p] < dist[t])) t = p;
            }
            // 访问节点t
            vis[t] = true;
            // 更新与t所有有关的节点的最短路径
            for (int j = 1; j <= n; j++) {
                if (adj[t][j] != Integer.MAX_VALUE && adj[t][j] != 0) {
                    dist[j] = Math.min(dist[j], adj[t][j] + dist[t]);
                }
            }
        }
        for (int i = 0; i < dist.length; i++) {
            System.out.println(dist[i]);
        }
    }

}