Dijkstra算法

概念

迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959 年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。

原理

贪心（略）

为什么Dijkstra算出来的是最短路径？

代码实现

说明：

1. 图的表示采用邻接矩阵方式

2. 计算出来的是源点到其余所有端点的距离

3. sptSet[]表示已经计算出最短距离的所有端点，dis[]表示距离

package path;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;

public class ShortestPath {
    public int getMinValue(int[] dis, boolean[] sptSet) {
        int minVal = Integer.MAX_VALUE;
        int index = -1;
        for (int i = 0; i < dis.length; i++) {
            if (!sptSet[i] && dis[i] < minVal) {
                minVal = dis[i];
                index = i;
            }
        }
        return index;
    }

    public int[] dijkstra(int[][] graph, int src) {
        int len = graph.length;
        int[] dis = new int[len];
        boolean[] sptSet = new boolean[len];
        HashMap<Integer, List<Integer>> hashMap = new HashMap<>();
        for (int i = 0; i < len; i++) {
            dis[i] = Integer.MAX_VALUE;
            List<Integer> list = new ArrayList<>();
            list.add(src);
            hashMap.put(i, list);
        }
        dis[src] = 0;
        // sptSet[src] = true;

        for (int count = 0; count < len; count++) {
            int u = getMinValue(dis, sptSet);
            sptSet[u] = true;
            for (int v = 0; v < len; v++) {
                if (!sptSet[v] && graph[u][v] != 0 && dis[v] > dis[u] + graph[u][v]) {
                    dis[v] = dis[u] + graph[u][v];
                }
            }
        }

        return dis;
    }

    public static void main(String[] args) {
        /* Let us create the example graph discussed above */
        int graph[][] = new int[][] { { 0, 4, 0, 0, 0, 0, 0, 8, 0 },
                { 4, 0, 8, 0, 0, 0, 0, 11, 0 },
                { 0, 8, 0, 7, 0, 4, 0, 0, 2 },
                { 0, 0, 7, 0, 9, 14, 0, 0, 0 },
                { 0, 0, 0, 9, 0, 10, 0, 0, 0 },
                { 0, 0, 4, 14, 10, 0, 2, 0, 0 },
                { 0, 0, 0, 0, 0, 2, 0, 1, 6 },
                { 8, 11, 0, 0, 0, 0, 1, 0, 7 },
                { 0, 0, 2, 0, 0, 0, 6, 7, 0 } };
        ShortestPath t = new ShortestPath();
        int[] dis = t.dijkstra(graph, 0);
        System.out.println(Arrays.toString(dis));
        // HashMap hashMap = new HashMap();
        // hashMap.get();
    }
}

参考资料

1. https://www.cnblogs.com/biyeymyhjob/archive/2012/07/31/2615833.html

2. https://www.geeksforgeeks.org/dijkstras-shortest-path-algorithm-greedy-algo-7/