Dijkstra算法c++详解

算法是一种用于寻找图中两点间最短路径的算法，适用于无负权边的图。下面是一个使用C++实现的算法示例，使用优先队列来优化算法效率：

#include <iostream>
#include <climits> // For INT_MAX
#include <vector>
#include <queue>   // For priority_queue

using namespace std;

const int V = 9; // 图的顶点数

// 定义一个结构体来存储顶点信息
struct Vertex {
    int vertex;
    int weight;
    bool operator<(const Vertex& v) const {
        return weight > v.weight;
    }
};

// 定义一个函数来实现Dijkstra算法
void dijkstra(vector<vector<int>> graph, int src) {
    vector<int> dist(V, INT_MAX); // 存储最短距离的向量
    bool visited[V];              // 记录顶点是否已访问
    vector<int> prev(V, -1);      // 存储最短路径上的前驱顶点

    // 初始化距离向量和前驱顶点向量
    dist[src] = 0;
    priority_queue<Vertex> pq;
    pq.push({src, 0});

    while (!pq.empty()) {
        int u = pq.top().vertex;
        pq.pop();

        if (visited[u]) continue;
        visited[u] = true;

        for (int v = 0; v < V; v++) {
            if (graph[u][v] != 0) {
                int alt = dist[u] + graph[u][v];
                if (alt < dist[v]) {
                    dist[v] = alt;
                    prev[v] = u;
                    pq.push({v, alt});
                }
            }
        }
    }

    // 打印最短距离和路径
    cout << "顶点\t距离\t路径\n";
    for (int i = 0; i < V; i++) {
        cout << i << "\t" << dist[i] << "\t";
        int j = i;
        while (j != -1) {
            cout << j << " <- ";
            j = prev[j];
        }
        cout << "start\n";
    }
}

// 主函数
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}
    };

    dijkstra(graph, 0);
    return 0;
}

在这个示例中：

1.  定义了图的顶点数。
2.  是一个二维向量，表示顶点之间的边权重，其中 0 表示两个顶点之间没有直接的边。
3.  函数实现了算法，计算从源顶点到所有其他顶点的最短路径，并打印结果。

你可以根据实际需要修改  和  的值，以适应不同的图结构。同时， 函数中使用了优先队列来优化算法的效率，优先队列中的元素按照权重从小到大排序。