Dijkstra最短路算法详解

最新推荐文章于 2026-06-29 07:01:47 发布

原创最新推荐文章于 2026-06-29 07:01:47 发布 · 819 阅读

19 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

题目

小明是蓝桥王国的王子，今天是他登基之日。

在即将成为国王之前，老国王给他出了道题，他想要考验小明是否有能力管理国家。

题目的内容如下：

蓝桥王国一共有 $N$ 个建筑和 $M$ 条单向道路，每条道路都连接着两个建筑，每个建筑都有自己编号，分别为 $\sim N$ 。（其中皇宫的编号为 $1$ ）

国王想让小明回答从皇宫到每个建筑的最短路径是多少，但紧张的小明此时已经无法思考，请你编写程序帮助小明回答国王的考核。

输入描述

输入第一行包含三个正整数 $N, M$ 。

第 $2$ 到 $M + 1$ 行每行包含三个正整数 $u, v, w$ ，表示 $\to v$ 之间存在一条距离为 $w$ 的路。

$\leq N \leq 3 \times 10^5$ ， $\leq m \leq 10^6$ ， $\leq u_i, v_i \leq N$ ， $\leq w_i \leq 10^9$ 。

输出描述

输出仅一行，共 $N$ 个数，分别表示从皇宫到编号为 $\sim N$ 建筑的最短距离，两两之间用空格隔开。（如果无法到达则输出 $- 1$ ）

输入输出样例

示例 1

输入

输出

0 1 3

题解

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

const int MAXN = 3e5 + 5;
const ll INF = 1e18;

vector<pair<int, ll>> adj[MAXN];  // 邻接表（0-based）
ll dist[MAXN];                    // 距离数组（0-based）

int main() {
    int N, M;
    scanf("%d %d", &N, &M);
    
    for (int i = 0; i < M; ++i) {
        int u, v;
        ll w;
        scanf("%d %d %lld", &u, &v, &w);
        u--;  // 关键操作：将输入的 1-based 转为 0-based
        v--;
        adj[u].emplace_back(v, w);
    }
    
    fill(dist, dist + N, INF);  // 0-based 数组范围 [0, N-1]
    dist[0] = 0;                // 源点是原编号 1，转为 0
    
    priority_queue<pair<ll, int>, vector<pair<ll, int>>, greater<>> pq;
    pq.emplace(0, 0);  // 入队源点 0
    
    while (!pq.empty()) {
        auto [d, u] = pq.top();
        pq.pop();
        
        if (d > dist[u]) continue;
        
        for (auto [v, w] : adj[u]) {
            if (dist[v] > dist[u] + w) {
                dist[v] = dist[u] + w;
                pq.emplace(dist[v], v);
            }
        }
    }
    
    // 输出时需将 0-based 转回 1-based
    for (int i = 0; i < N; ++i) {
        if (i > 0) printf(" ");
        printf("%lld", dist[i] != INF ? dist[i] : -1LL);
    }
    
    return 0;
}

Dijkstra最短路算法详解

1. 现实生活中的例子

想象你正在使用导航软件规划从北京到上海的驾车路线。你希望找到一条总里程最短的路径，这就是典型的最短路问题。

北京 ----300km---- 济南 ----400km---- 南京 ----300km---- 上海
   \                                                    /
    \                                                  /
     \                                                /
      800km                                         200km
       \                                            /
        \                                          /
         \                                        /
          --------------- 徐州 ------------------

2. 代码结构解析

2.1 关键数据结构

vector<pair<int, ll>> adj[MAXN];  // 邻接表存储图
vector<ll> dist(MAXN,INF);        // 存储到每个点的最短距离
priority_queue<pair<ll, int>>     // 优先队列（小根堆）

2.2 算法步骤

初始化：
- 将起点距离设为0
- 其他点距离设为无穷大
- 将起点放入优先队列
松弛操作：
- 每次取出队列中距离最小的点
- 尝试更新它的所有邻居的距离

3. 代码详解

3.1 图的存储

vector<pair<int, ll>> adj[MAXN];  // 邻接表（0-based）

adj[u] 存储了从点u出发能到达的所有点
每个元素是一个pair，first是目标点编号，second是边权（距离）

3.2 输入处理

for (int i = 0; i < M; ++i) {
    int u, v;
    ll w;
    cin >> u >> v >> w;
    u--;  // 将输入的 1-based 转为 0-based
    v--;
    adj[u].emplace_back(v, w);
}

读入M条边的信息
由于输入是1-based（从1开始编号），需要转换为0-based（从0开始编号）

3.3 核心算法实现

while (!pq.empty()) {
    auto [d, u] = pq.top();
    pq.pop();
    
    if (d > dist[u]) continue;  // 如果当前距离已不是最优，跳过
    
    for (auto [v, w] : adj[u]) {
        if (dist[v] > dist[u] + w) {  // 尝试更新邻居的距离
            dist[v] = dist[u] + w;
            pq.emplace(dist[v], v);
        }
    }
}

4. 算法执行过程示例

假设有以下图：

0 ---2--- 1
|         |
4         1
|         |
2 ---3--- 3

执行过程：

初始状态：
- dist[0] = 0
- dist[1,2,3] = INF
- pq = {(0,0)}
第一次迭代：
- 取出0号点
- 更新1号点：dist[1] = 2
- 更新2号点：dist[2] = 4
- pq = {(2,1), (4,2)}
第二次迭代：
- 取出1号点
- 更新3号点：dist[3] = 3
- pq = {(3,3), (4,2)}

以此类推…

5. 时间复杂度分析

总时间复杂度：O(MlogN)
- M是边数
- N是点数
- 每条边最多被处理一次
- 优先队列的操作是logN级别

6. 应用场景

导航软件中的最短路径规划
网络路由选择
社交网络中的最短关系链
游戏中的寻路算法

7. 注意事项

本算法只适用于边权为非负数的情况
如果存在负权边，需要使用Bellman-Ford算法
数组大小要开够（MAXN的值要足够大）
注意整数溢出的问题（使用long long类型）

标签

#算法 #c++