Dijkstra算法详解：从原理到实现与优化

1. 项目背景与问题定义

单源最短路径（Single-Source Shortest Path，SSSP）是图论中的经典问题，也是算法竞赛中的高频考点。洛谷P4779作为标准模板题，要求实现一个能够处理带权有向图的Dijkstra算法，解决从固定起点到图中所有其他节点的最短路径问题。这个问题在实际应用中广泛存在，比如导航软件中的路线规划、网络路由中的最优路径选择等场景。

我第一次接触这个问题是在准备区域赛时，当时被各种优化版本绕得头晕。后来发现吃透标准版才是关键，就像练武术要先扎马步一样。本文将拆解最朴素的Dijkstra实现方案，适合算法入门者建立正确的思维模型。

2. 算法核心原理剖析

2.1 Dijkstra算法基本思想

Dijkstra算法的本质是贪心策略与动态规划的结合。其核心在于维护一个"已确定最短路径"的节点集合S，每次从剩余节点中选择当前距离起点最近的节点加入S，并松弛其邻接边。这个过程就像用探照灯一层层照亮地图，每次总是先照亮最近的未探索区域。

算法正确性的关键在于：在非负权图中，局部最优解能保证全局最优。用数学归纳法可以证明，当节点u被加入S时，dist[u]已经是最短距离。这个特性使得Dijkstra不能处理负权边——负权会破坏贪心选择的最优子结构。

2.2 时间复杂度分析

基础实现使用线性扫描查找最小距离节点：

• 每次查找最小值：O(V)
• 总共V次操作：O(V²)
• 松弛操作总次数：O(E)
• 合计复杂度：O(V² + E)

对于稀疏图（E≈V），这显然不够高效。后面我们会看到如何用优先队列优化到O((V+E)logV)。

3. 标准版实现详解

3.1 数据结构设计

cpp复制const int MAXN = 1e5 + 5;
const int INF = 0x3f3f3f3f;

struct Edge {
    int to, weight;
};

vector<Edge> adj[MAXN];  // 邻接表存图
int dist[MAXN];          // 存储最短距离
bool visited[MAXN];      // 标记是否已确定最短路径

这里有几个关键点：

1. 邻接表比邻接矩阵更节省空间，尤其适合稀疏图
2. INF取值0x3f3f3f3f既满足32位整数范围，又方便memset初始化
3. visited数组是朴素实现的关键，避免重复处理节点

3.2 算法主体实现

cpp复制void dijkstra(int start) {
    memset(dist, 0x3f, sizeof(dist));
    dist[start] = 0;
    
    for (int i = 0; i < n; ++i) {  // 最多循环n次
        int u = -1;
        // 步骤1：找到未访问的最近节点
        for (int j = 1; j <= n; ++j) {
            if (!visited[j] && (u == -1 || dist[j] < dist[u])) {
                u = j;
            }
        }
        
        if (u == -1 || dist[u] == INF) break;  // 剩余节点不可达
        visited[u] = true;
        
        // 步骤2：松弛邻接边
        for (const Edge& e : adj[u]) {
            if (dist[e.to] > dist[u] + e.weight) {
                dist[e.to] = dist[u] + e.weight;
            }
        }
    }
}

注意：这个版本在OJ上可能无法通过全部测试用例（当V>1e4时会超时），但作为教学示例展示了最清晰的算法逻辑。

4. 优先队列优化版本

4.1 优化思路

每次线性查找最小值是性能瓶颈。改用优先队列（堆）可以将查找操作从O(V)降到O(logV)。但需要注意：

1. C++的priority_queue默认是大根堆，需要转换为小根堆
2. 同一个节点可能被多次加入队列（因为距离被多次更新）
3. 需要判断出队的节点是否已被处理过

4.2 优化实现代码

cpp复制void dijkstra_priority_queue(int start) {
    memset(dist, 0x3f, sizeof(dist));
    dist[start] = 0;
    
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<>> pq;
    pq.emplace(0, start);
    
    while (!pq.empty()) {
        auto [d, u] = pq.top();
        pq.pop();
        
        if (visited[u]) continue;
        visited[u] = true;
        
        for (const Edge& e : adj[u]) {
            if (dist[e.to] > d + e.weight) {
                dist[e.to] = d + e.weight;
                pq.emplace(dist[e.to], e.to);
            }
        }
    }
}

这个版本的复杂度降为O((V+E)logV)，能够处理V=1e5规模的图。实测在洛谷P4779上运行时间在200ms左右。

5. 关键细节与踩坑记录

5.1 初始化陷阱

常见错误是忘记初始化或初始化不当：

cpp复制// 错误示例1：漏初始化
dist[start] = 0;  // 其他dist值未定义

// 错误示例2：用循环赋值导致超时
for(int i=1; i<=n; i++) dist[i] = INF;  // 当n很大时慢于memset

最佳实践：对于大数组，使用memset配合0x3f是最优选择。因为0x3f3f3f3f的每个字节都是0x3f，memset能按字节快速填充。

5.2 重复入队问题

在优化版本中，同一个节点可能因为距离更新被多次加入队列。如果不加判断直接处理，会导致：

1. 不必要的计算（该节点的后续松弛操作重复执行）
2. 最坏情况下复杂度退化为O(ElogE)

解决方案就是通过visited数组过滤，或者更优雅的做法是：

cpp复制if (d > dist[u]) continue;  // 当前出队的不是最新距离，直接跳过

5.3 无穷大表示方法

不同场景下的INF取值需要谨慎：

• 一般情况：0x3f3f3f3f（约1e9）
• 需要相加时：0x3f3f3f3f/2（防止溢出）
• long long范围：0x3f3f3f3f3f3f3f3fLL

6. 测试用例设计技巧

验证Dijkstra实现时需要覆盖以下边界情况：

1. 单节点图（自环测试）

text复制1 0
1

2. 链式图（验证顺序处理）

text复制3 2
1 2 5
2 3 7

3. 存在重边的情况

text复制2 3
1 2 4
1 2 7
1 2 3

4. 不连通图（部分节点不可达）

text复制4 2
1 2 1
3 4 1

在洛谷提交前，建议本地运行这些测试用例。我曾在区域赛热身时因为没测重边情况导致WA，这个教训值得记取。

7. 性能优化进阶

7.1 堆优化对比测试

使用不同数据结构实现优先队列的实测性能（V=1e5, E=5e5）：

虽然理论上斐波那契堆的O(E+VlogV)更优，但实际竞赛中STL的priority_queue已经足够，且更不容易出错。

7.2 输入输出优化

对于大规模图（V,E>1e5），IO成为瓶颈。建议：

cpp复制ios::sync_with_stdio(false);
cin.tie(nullptr);

或者使用快速读入函数：

cpp复制inline int read() {
    int x = 0; char c = getchar();
    while (!isdigit(c)) c = getchar();
    while (isdigit(c)) x = x*10 + c-'0', c = getchar();
    return x;
}

8. 算法扩展思考

虽然Dijkstra是SSSP问题的经典解法，但在不同场景下还有其他选择：

1. 存在负权边：Bellman-Ford算法（O(VE)）或SPFA
2. 全源最短路径：Floyd-Warshall算法（O(V³)）
3. 特殊图结构：
   • DAG：拓扑排序后线性处理（O(V+E)）
   • 单位权图：BFS（O(V+E)）

理解这些算法的适用场景和限制条件，才能在竞赛中快速选择最佳工具。就像木匠不会只用一把锤子解决所有问题，优秀的选手需要根据问题特点灵活选择算法。