全局路径算法-Dijkstra算法

Dijkstra算法

概述：从【未计算出最短距离点集合】中选出距离起点距离最短的点，将其加入到【已计算出最短距离点集合】中。根据【已计算出最短距离点集合】中的点为桥梁，更新剩下【未计算出最短距离点】到起点的距离。

一、 过程

（重点）算法要点

result：已求出 最小路径的顶点
notFound：未求出 最小路径的顶点，里面的值是 到起点的距离

初始，result={A(0)} 中只有起点 A，notFound={B(2),C(∞),D(6)} 中是除了 A 点的其他点，里面的值是到起点的距离（例如 B(2) 代表 B点到起点的距离为 2）

然后，从「未求出最短路径的点」notFound 中取出 最短路径的点 B(2) ，然后通过 B(2) 为桥梁 刷新「未求出最短路径的点」的距离

取出 最短路径的点：
从「未求出最短路径的点」notFound 中取出 最短路径的点 B(2)，放入结果 result 中，结果如下：

「未求出最短路径点」 notFound={C(∞),D(6)}，「已求出最短路径的点 」result={A(0),B(2)}

刷新距离：
通过 B(2) 为桥梁，刷新距离。

例如 AD = 6 < AB + BD = 4 以 B(2) 为桥梁的距离更短，就刷新「未求出最短路径点」D(6) 的距离为 D(4)

notFound={C(∞),D(4)}

同理刷新 C(∞) 的距离为 C(5) ，最后结果如下：

「未求出最短路径点」 notFound={C(5),D(4)} ，「已求出最短路径的点」result={A(0),B(2)}

然后，从「未求出最短路径的点」notFound 中取出 最短路径的点 D(4) ，然后通过 D(4) 为桥梁 刷新「未求出最短路径的点」的距离

同理，最后结果如下：

「未求出最短路径点」 notFound={C(5)} ，「已求出最短路径的点」result={A(0),B(2),D(4)}

然后，从「未求出最短路径的点」notFound 中取出 最短路径的点 C(5) ，算法结束

result={A(0),B(2),D(4),C(5)} 就是最终所求的 最短距离

二、代码实现

#include <iostream>
#include <vector>
#include <climits>

using namespace std;

#define INF INT_MAX

int minDistance(const vector<int>& dist, const vector<bool>& sptSet, int V) {
    int min = INF, min_index;

    for (int v = 0; v < V; v++) {
        if (!sptSet[v] && dist[v] <= min) {
            min = dist[v], min_index = v;
        }
    }

    return min_index;
}

void printSolution(const vector<int>& dist, int V) {
    cout << "Vertex \t Distance from Source" << endl;
    for (int i = 0; i < V; i++)
        cout << i << " \t\t " << dist[i] << endl;
}

void dijkstra(const vector<vector<int>>& graph, int src, int V) {
    vector<int> dist(V, INF); 
    vector<bool> sptSet(V, false);

    dist[src] = 0;

    for (int count = 0; count < V - 1; count++) {
        int u = minDistance(dist, sptSet, V);
        sptSet[u] = true;

        for (int v = 0; v < V; v++) {
            if (!sptSet[v] && graph[u][v] && dist[u] != INF && dist[u] + graph[u][v] < dist[v]) {
                dist[v] = dist[u] + graph[u][v];
            }
        }
    }

    printSolution(dist, V);
}

int main() {
    vector<vector<int>> graph = { { 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 } };
    int V = graph.size();
    dijkstra(graph, 0, V);

    return 0;
}

代码结果

原文：https://zhuanlan.zhihu.com/p/338414118