迪杰斯特拉(Dijkstra)算法

1，迪杰斯特拉算法介绍

迪杰斯特拉算法(Dijkstra)也叫狄克斯特拉算法，它使用类似广度优先搜索的方法，解决从一个顶点到其他所有顶点的最短路径问题，它解决的是加权图(不能有负权)的最短路径问题。

从起始点开始，采用贪心算法的策略，每次选择一个没被标记且距离起始点最近的顶点，把它标记下，然后更新和它邻接的顶点 ……，直到所有顶点都计算完为止。

如上图所示，假如计算从上海到其他所有城市的最短时间，上面的时间有可能是开车，有可能是高铁也可能是坐飞机，和真实距离不成正比。

我们从起始点开始，使用一个数组 dis ，数组中 dis[j] 的值表示从起始点到顶点 j 的时间，刚开始的时候，起始点到他自己为 0 ，到其他顶点都为无穷大，如下图所示。

如果想要减少从起始点到 j 的时间，唯一的方式就是需要寻找一个中转站 k 。从起始点到 k 的时间为 dis[k] ，从 k 到 j 的时间为 g[k][j] ，然后判断中转的总时间 dis[k] + g[k][j] 是否小于 dis[j] ，如果中转时间小于 dis[j] ，就更新 dis[j] 。

比如最上面图中，从起始点到南京的时间是 3 小时，如果通过杭州中转，时间就会变成 2 小时。核心代码是下面这行。

dis[j] = min(dis[j], dis[k] + g[k][j]);

迪杰斯特拉算法的解题思路如下：

1，从起始点开始计算所有和它相连的点(也就是起始点指向的点)，计算完之后把起始点标记下(表示已经计算过了)。
2，找出离起始点最近且没有被标记过的点 v ，计算所有和 v 相连且没有被标记过的点，计算完之后把 v 标记下。
3，重复上面的步骤 2 ，直到所有顶点都标记完为止。

2，迪杰斯特拉算法的代码实现

迪杰斯特拉算法使用的是贪心的策略，每次都是从未标记的顶点中找到一个离起始点最近的点，用它来更新所有和它连接且未被标记过的点，代码比较简单，我们来看下。

Java 代码：

private void test() {
    int[][] g = {{0, 1, 3, 0, 0, 0},// 图的邻接矩阵。
            {0, 0, 1, 4, 2, 0},
            {0, 0, 0, 5, 5, 0},
            {0, 0, 0, 0, 0, 3},
            {0, 0, 0, 1, 0, 6},
            {0, 0, 0, 0, 0, 0}};
    dijkstra(g, 0);
}

/**
 * @param g     图的邻接矩阵
 * @param start 起始点
 */
public void dijkstra(int[][] g, int start) {
    int n = g.length;// 顶点的个数。
    int[] dis = new int[n];// 每个点到起始点的距离
    // 起始点到其他所有顶点默认给一个非常大的值，
    // 要注意下面加的时候防止出现溢出。
    Arrays.fill(dis, Integer.MAX_VALUE >> 1);
    dis[start] = 0;// 起始点到自己的值是 0 。
    boolean visited[] = new boolean[n];// 标记哪些顶点被访问过
    for (int i = 0; i < n; i++) {
        int k = -1;// 下一个没被标记且离起始点最近的顶点。
        int min = Integer.MAX_VALUE; // min 是 k 到起始点的值。
        for (int j = 0; j < n; j++) {// 寻找 k。
            if (!visited[j] && dis[j] < min) {
                min = dis[j];
                k = j;
            }
        }
        visited[k] = true;// 标记
        for (int j = 0; j < n; j++) {// 核心代码。
            // 顶点 j 没有被标记，并且 k 有到 j 的路径，并且这个路径更近，就更新。
            if (!visited[j] && g[k][j] != 0 && dis[k] + g[k][j] < dis[j])
                dis[j] = dis[k] + g[k][j];
        }
    }
    // 打印数组dis的值，测试使用。
    for (int di : dis)
        System.out.print(di + ",");
}

C++ 代码：

/**
 * @param g       图的邻接矩阵
 * @param start   起始点
 */
void dijkstra(vector<vector<int>> &g, int start) {
    const int n = g.size();// 顶点的个数。
    vector<int> dis(n, INT_MAX/2);// 每个点到起始点的距离
    dis[start] = 0;// 起始点到自己的值是 0 。
    vector<bool> visited(n, false); // 标记哪些顶点被访问过
    for (int i = 0; i < n; i++) {
        int k = -1;// 下一个没被标记且离起始点最近的顶点。
        int min = INT_MAX; // min 是 k 到起始点的值。
        for (int j = 0; j < n; j++) {// 寻找 k。
            if (!visited[j] && dis[j] < min) {
                min = dis[j];
                k = j;
            }
        }
        visited[k] = true;// 标记
        for (int j = 0; j < n; j++) {// 核心代码。
            // 顶点 j 没有被标记，并且 k 有到 j 的路径，并且这个路径更近，就更新。
            if (!visited[j] && g[k][j] != 0 && dis[k] + g[k][j] < dis[j])
                dis[j] = dis[k] + g[k][j];
        }
    }
    // 打印数组dis的值，测试使用。
    for (int di: dis)
        cout << di << ",";
}

3，迪杰斯特拉算法的堆优化

我们看到上面代码中外面的循环是遍历顶点，里面的循环主要是查找离起始点最近的顶点 v ，然后更新和 v 邻接的顶点。

如果这个图是个稀疏图，边特别少的话，在一个个查找很明显效率不高，所以在这种情况下可以使用最小堆来优化下，每次与顶点 v 邻接的点计算完之后把它加入到堆中，下次循环的时候直接弹出堆顶元素即可，它就是离起始点最近的点。（使用堆优化，图最好使用邻接表的存储方式）

Java 代码：

/**
 * 使用堆优化的算法
 *
 * @param g     图的邻接矩阵
 * @param start 起始点
 */
public void dijkstra(int[][] g, int start) {
    int n = g.length;// 顶点的个数。
    int[] dis = new int[n];// 每个点到起始点的距离
    Arrays.fill(dis, Integer.MAX_VALUE >> 1);
    dis[start] = 0;// 起始点到自己的值是 0 。
    boolean visited[] = new boolean[n];// 标记哪些顶点被访问过
    // 创建堆，根据到起始点的距离排序
    PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
    pq.offer(new int[]{0, start});// 起始点到它自己的距离是 0 。
    for (int i = 0; i < n; i++) {
        if (pq.isEmpty()) break; // 如果堆为空，退出循环
        // 每次出队都是离起始点最近且没被标记过的顶点。
        int k = pq.poll()[1];
        visited[k] = true;// 标记
        for (int j = 0; j < n; j++) {// 核心代码。
            // 顶点 j 没有被标记，并且 k 有到 j 的路径，并且这个路径更近，就更新。
            if (!visited[j] && g[k][j] != 0 && dis[k] + g[k][j] < dis[j]) {
                // 如果顶点 j 经过 k 到起始点的距离更近，就更新顶点 j 到
                // 起始点的距离，并把它添加到堆中。
                dis[j] = dis[k] + g[k][j];
                pq.offer(new int[]{dis[j], j});
            }
        }
    }
    // 打印数组dis的值，测试使用。
    for (int di : dis)
        System.out.print(di + ",");
}

C++ 代码：

void dijkstra(vector<vector<int>> &g, int start) {
    int n = g.size(); // 顶点的个数
    vector<int> dis(n, INT_MAX / 2); // 每个点到起始点的距离
    dis[start] = 0; // 起始点到自己的值是 0
    vector<bool> visited(n, false); // 标记哪些顶点被访问过
    // 创建堆，根据到起始点的距离排序
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<>> pq;
    pq.emplace(0, start); // 起始点到它自己的距离是 0
    for (int i = 0; i < n; i++) {
        // 每次出队都是离起始点最近且没被标记过的顶点
        if (pq.empty()) break; // 如果堆为空，退出循环
        int k = pq.top().second;
        pq.pop();
        visited[k] = true; // 标记
        for (int j = 0; j < n; j++) { // 核心代码
            // 顶点 j 没有被标记，并且 k 有到 j 的路径，并且这个路径更近，就更新
            if (!visited[j] && g[k][j] != 0 && dis[k] + g[k][j] < dis[j]) {
                // 如果顶点 j 经过 k 到起始点的距离更近，就更新顶点 j 到起始点的距离，并把它添加到堆中
                dis[j] = dis[k] + g[k][j];
                pq.emplace(dis[j], j);
            }
        }
    }

    // 打印数组dis的值，测试使用
    for (int di: dis)
        cout << di << ",";
    cout << endl;
}

4，为什么迪杰斯特拉算法不能处理带有负权边的图

为什么通过上述的操作可以保证得到的 dis 值最小？因为这里的图是没有负权边的，值只能越加越大，我们不断选择最小值进行标记然后更新和它邻接的点，即贪心的思路，最终保证起始点到每个顶点的值都是最小的。

如果有负权边在使用 Dijkstra 算法就行不通了，如下图所示，其中有负权边。

最后的结果是起始点到顶点 2 的值是 3 ，但实际上如果选择 0->1->2 这条路径的值是 2 ，会更小，所以有负权边并不适合 Dijkstra 算法。如果图是有环的可不可以使用 Dijkstra 算法呢？实际上只要没有负权边无论有环无环都是可以使用 Dijkstra 算法的。

如果有负权边该怎么解决呢？我们可以使用贝尔曼-福特算法(Bellman–Ford)和最短路径快速算法(Shortest Path Faster Algorithm：简称：SPFA)，这两种算法虽然可以解决带有负权边的图，但不能解决有负权回路的图，关于这两种算法，后面我们也都会介绍。
有负权边并不适合 Dijkstra 算法。如果图是有环的可不可以使用 Dijkstra 算法呢？实际上只要没有负权边无论有环无环都是可以使用 Dijkstra 算法的。

如果有负权边该怎么解决呢？我们可以使用贝尔曼-福特算法(Bellman–Ford)和最短路径快速算法(Shortest Path Faster Algorithm：简称：SPFA)，这两种算法虽然可以解决带有负权边的图，但不能解决有负权回路的图，关于这两种算法，后面我们也都会介绍。