Dijkstra 优先队列实现

Dijkstra算法是一种用于解决单源最短路径问题的算法，它利用了优先队列的特性来实现时间复杂度更低的计算。下面是Dijkstra算法利用优先队列实现的步骤：

1. 初始化节点：将每个节点的路径值设为一个极大值，源点的路径值设为0。
2. 定义一个优先队列，队列中的元素记录了节点的编号和节点的最短路径值，将源点压入队列。
3. 当队列非空时，执行以下操作：
- 从队列中取出队顶的节点u，以及u的最短路径值w。
- 遍历节点u的所有边，如果能找到节点v的最短路径值小于v的当前值，更新v的最短路径值，并将v压入队列。
4. 结束。

使用优先队列求解的时间复杂度为O(nlogn)。

以下是C++代码实现Dijkstra算法的示例：

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

using namespace std;

// 定义边的结构体
struct Edge {
    int to; // 边的终点
    int weight; // 边的权重
};

// 定义节点的结构体
struct Node {
    int id; // 节点的编号
    int dist; // 节点的最短路径值

    // 重载小于运算符，用于优先队列的比较
    bool operator<(const Node& other) const {
        return dist > other.dist;
    }
};

// Dijkstra算法实现
void dijkstra(vector<vector<Edge>>& graph, int source) {
    int n = graph.size(); // 节点的个数
    vector<int> dist(n, INT_MAX); // 节点的最短路径值
    vector<bool> visited(n, false); // 节点的访问状态

    // 创建优先队列
    priority_queue<Node> pq;

    // 初始化源点
    dist[source] = 0;
    pq.push({source, 0});

    while (!pq.empty()) {
        // 取出队顶的节点和最短路径值
        Node node = pq.top();
        pq.pop();
        int u = node.id;
        int w = node.dist;

        // 如果节点已经访问过，则跳过
        if (visited[u]) {
            continue;
        }

        // 标记节点为已访问
        visited[u] = true;

        // 遍历节点的所有边
        for (Edge& edge : graph[u]) {
            int v = edge.to;
            int weight = edge.weight;

            // 如果能找到节点v的最短路径值小于v的当前值，更新v的最短路径值，并将v压入队列
            if (dist[u] + weight < dist[v]) {
                dist[v] = dist[u] + weight;
                pq.push({v, dist[v]});
            }
        }
    }

    // 输出最短路径值
    for (int i = 0; i < n; i++) {
        cout << "最短路径值[" << source << " -> " << i << "]: " << dist[i] << endl;
    }
}

int main() {
    int n = 5; // 节点的个数
    vector<vector<Edge>> graph(n); // 图的邻接表表示

    // 添加边
    graph[0].push_back({1, 10});
    graph[0].push_back({4, 5});
    graph[1].push_back({2, 1});
    graph[1].push_back({4, 2});
    graph[2].push_back({3, 4});
    graph[3].push_back({2, 6});
    graph[3].push_back({0, 7});
    graph[4].push_back({1, 3});
    graph[4].push_back({2, 9});
    graph[4].push_back({3, 2});

    int source = 0; // 源点的编号

    // 调用Dijkstra算法
    dijkstra(graph, source);

    return 0;
}