[leetcode] 743. 网络延迟时间 Dijkstra Floyd 双解 java

Problem: 743. 网络延迟时间

Dijkstra

时间复杂度:

添加时间复杂度, 示例： $O(n^2)$

空间复杂度:

添加空间复杂度, 示例： $O(n^2)$

class Solution {
    public int networkDelayTime(int[][] times, int n, int k) {
        // 构建邻接矩阵
        int[][] graph = new int[n][n];
        int[] dist = new int[n];  // 源点到各个顶点的最短距离
        boolean[] visited = new boolean[n];  // 已经确定最短路径的节点
        final int INF = Integer.MAX_VALUE / 2;
        Arrays.fill(dist, INF);
        for (int i = 0; i < n; i++) {  // 初始化为无穷大
            Arrays.fill(graph[i], INF);
        }
        for (int[] time : times) {
            // time[0] 起点 time[1] 终点 time[2] 距离
            // time中的节点从1开始数，需要减1
            graph[time[0] - 1][time[1] - 1] = time[2];
        }
        for (int i = 0; i < n; i++) {
            // 初始化源点到已经连通的节点的最短距离
            dist[i] = graph[k - 1][i];
        }
        dist[k - 1] = 0; // 确保不是无穷大的距离，防止最后比较的时候return -1
        visited[k - 1] = true; // 标记为已访问
        for (int i = 0; i < n - 1; i++) { // 只需要访问n-1个节点,i没有用
            int min = INF;
            int u = -1;
            for (int j = 0; j < n; j++) {
                // 找到未被访问，且距离源点最短的那个节点
                if (!visited[j] && dist[j] < min) {
                    min = dist[j];
                    u = j;
                }
            }
            if (u == -1) return -1; //没有找到连通的路径，说明不能访问所有节点
            visited[u] = true;  // 标记已访问
            for (int j = 0; j < n; j++) {
                // 从这个节点开始更新路径
                if (!visited[j] && graph[u][j] + dist[u] < dist[j]) {
                    dist[j] = graph[u][j] + dist[u];
                }
            }
        }
        int ans = 0;
        for (int i = 0; i < n; i++) {
            // 最大路径即为找寻信号所需时间
            ans = Math.max(ans, dist[i]);
        }
        return ans == INF ? -1 : ans;
    }
}

Floyd

时间复杂度:

添加时间复杂度, 示例： $O(n^3)$

空间复杂度:

添加空间复杂度, 示例： $O(n^2)$

class Solution {
    public int networkDelayTime(int[][] times, int n, int k) {
        int[][] graph = new int[n][n];  // 构建邻接矩阵
        final int INF = Integer.MAX_VALUE / 2;
        for (int i = 0; i < n; i++)  // 初始化为无穷大
            for (int j = 0; j < n; j++)
                graph[i][j] = i==j ? 0 : INF;
        for (int[] time : times)
            // time[0] 起点 time[1] 终点 time[2] 距离
            // time中的节点从1开始数，需要减1
            graph[time[0] - 1][time[1] - 1] = time[2];
        // 每个点都为中转点
        for (int o = 0; o < n; o++)
            for (int x = 0; x < n; x++) // 所有入度
                for (int y = 0; y < n; y++)  // 所有出度
                        //如果AB+BC<AC就刷新距离和路径,A入C出B中转点
                        graph[x][y] = Math.min(graph[x][y],graph[x][o] + graph[o][y]);
        int ans = 0;
        for (int i = 0; i < n; i++)
            ans = Math.max(graph[k-1][i],ans);
        return ans == INF ? -1 : ans;

    }
}