Dijkstra最短路由算法，求任意两点之间的最短距离【Java】

一、问题

求下图中节点0到节点5之间的最短距离

二、方法

Dijkstra最短路由算法。本文不再赘述，直接上代码，如果不懂，可以参考 文章

三、代码

public class MyDijkstra {
    public static void main(String[] args) {
        int[][] nums = {{ 0, 6, 3, -1, -1, -1 }, 
                        { 6, 0, 2, 5, -1, -1 }, 
                        { 3, 2, 0, 3, 4, -1 }, 
                        { -1, 5, 3, 0, 2, 3 }, 
                        { -1, -1, 4, 2, 0, 5 }, 
                        { -1, -1, -1, 3, 5, 0 }};
        getShortestPaths(nums, 0, 5);
    }

    /**
     * Dijkstra算法，求任意两点之间的最短路径
     * 
     * @param nums：二维矩阵，代表两个节点之间的距离，其中-1代表两点之间无法直接相连
     * @param src：源节点
     * @param des：目的节点
     * @return 源节点到目的节点之间的最短距离
     */

    public static int getShortestPaths(int[][] nums, int src, int des) {
        int[] result = new int[nums.length]; // 用于存放节点src到其它节点的最短距离
        boolean[] visited = new boolean[nums.length]; // 用于判断节点是否被遍历
        ArrayList<Integer> path = new ArrayList<Integer>(); // 用于存放(src, des)之间的最短路径

        // step1：初始化，将src节点设置为已经访问，并且初始化该节点到其他所有节点之间的距离
        visited[src] = true;
        path.add(src);

        for (int i = 0; i < nums.length; i++) {
            result[i] = nums[src][i];
        }

        while (true) {
            // step2：找到剩余未访问的节点中，距离src最近的一个节点，作为curNode
            int curNode = getNearestNode(nums, visited, result);

            // step3：更新所有节点距离src节点的最短距离（需要考虑curNode）
            update(nums, curNode, visited, result, path);

            System.out.println("选择节点 " + curNode + " 更新后的result为：" + Arrays.toString(result));
            if (curNode == des) {
                break;
            }
        }

        System.out.println("节点" + src + "到节点" + des + "经过的最短路径是：" + path);
        System.out.println("节点" + src + "到节点" + des + "之间的最短距离是：" + result[des]);
        return result[des];
    }

    // 找到剩余未访问的节点中，距离源节点最近的一个节点编号
    public static int getNearestNode(int[][] nums, boolean[] visited, int[] result) {
        int minIndex = -1;
        int minLength = Integer.MAX_VALUE;
        for (int i = 0; i < nums.length; i++) {
            if (!visited[i] && result[i] != -1 && result[i] < minLength) {
                minIndex = i;
                minLength = result[i];
            }
        }

        return minIndex;
    }

    // 更新与curNode节点直接相连接的未被访问的节点距离，专业术语叫 “松弛”
    public static void update(int[][] nums, int curNode, boolean[] visited, int[] result, ArrayList<Integer> path) {
        visited[curNode] = true;
        path.add(curNode);

        for (int j = 0; j < nums.length; j++) {
            // 节点j未访问过 && 节点curNode与节点j之间需要直接相连
            if (!visited[j] && nums[curNode][j] != -1) {
                // 更新result[j]
                if (result[j] > result[curNode] + nums[curNode][j] || result[j] == -1) {
                    result[j] = result[curNode] + nums[curNode][j];
                }
            }
        }
    }
}

四、结果

可以看出，节点0到节点5之间经过的最短路径是：0 -> 2 -> 1 -> 3 -> 4 -> 5 ，最短距离是9

五、参考

（1）文章：java实现Dijkstra算法_南 墙-CSDN博客_dijkstra算法java实现

（2）书籍：推荐《啊哈！算法》中关于Dijkstra算法的介绍，通俗易懂