leetcode - 743

网络延迟时间

迪杰斯特拉的朴素算法流程：

邻接矩阵的方法

点击查看代码

class Solution {
    public int networkDelayTime(int[][] times, int n, int k) {
        //初始化一些必要参数
        int INF = Integer.MAX_VALUE/2;
        int[][] g = new int[n][n];
        for(int[] row : g){
            Arrays.fill(row, INF);
        }
        for(int[] t : times){
            int x = t[0] - 1;
            int y = t[1] - 1;
            int wt = t[2];
            g[x][y] = wt;
        }
        int[] dis = new int[n];
        Arrays.fill(dis, INF);
        dis[k-1] = 0;
        boolean[] vis = new boolean[n];
        int ans = 0;
        while(true){
            //开始执行dijsktra算法
            //1.选择当前操作数
            int x = -1;
            for(int i = 0; i < n; i++){
                if(!vis[i] && (x ==-1 || dis[i] < dis[x])){
                    x = i;
                }
            }
            //2.更新结果
            //x == -1说明结束了
            if(x == -1) return ans;
            //如果该节点不可达，那么会出现dis[x] == INF
            if(dis[x] == INF) return -1;
            
            //正常更新dis
            vis[x] = true;
            ans = dis[x];
            for(int y = 0; y < n; y++){
                dis[y] = Math.min(dis[y],  dis[x]+g[x][y]);
            }

        }
    }
}

##node节点多，edge少，适合用邻接表

点击查看代码

class Solution {
    public int networkDelayTime(int[][] times, int n, int k) {
        //初始化一些必要参数

        //开一个邻接表
        List<int[]>[] g = new ArrayList[n];
        for(int i = 0; i < n; i++){
            g[i] = new ArrayList<>();
        }
        for(int[] t : times){
            int x = t[0] - 1;
            int y = t[1] - 1;
            int wt = t[2];
            g[x].add(new int[]{y,wt});
        }
        //可以增加输出查看表内内容
        for(List<int[]>a : g){
            for(int[] b : a){
                System.out.println(b[0]+1+","+b[1]);
            }
        }

        int INF = Integer.MAX_VALUE/2;
        // int[][] g = new int[n][n];
        // for(int[] row : g){
        //     Arrays.fill(row, INF);
        // }
        // for(int[] t : times){
        //     int x = t[0] - 1;
        //     int y = t[1] - 1;
        //     int wt = t[2];
        //     g[x][y] = wt;
        // }

        int[] dis = new int[n];
        Arrays.fill(dis, INF);
        dis[k-1] = 0;
        // boolean[] vis = new boolean[n];
        int ans = 0;

        PriorityQueue<int[]> pq = new PriorityQueue<>((a,b)-> a[0]- b[0]);
        pq.offer(new int[]{0, k-1});
        int count = n;
        while(!pq.isEmpty()){
            int[] p = pq.poll();
            int disP = p[0];
            int x = p[1];
            if(disP > dis[x]) continue;
            ans = disP;
            count--;
            //更新距离
            for(int[] e : g[x]){
                int y =e[0];
                int disY = e[1]+disP;
                if(disY < dis[y]){
                    dis[y] = disY;
                    pq.offer(new int[]{disY, y});
                }
            }
        }
        return count != 0?-1:ans;
    }
}