图论最短路算法详解：Dijkstra与Bellman-Ford实战

鲸晚好梦

1. 最短路问题入门与核心算法解析

作为一名算法竞赛选手，最短路问题是我在图论领域遇到的第一个重要课题。记得初学Dijkstra算法时，那种从迷茫到顿悟的过程至今难忘。本文将系统梳理最短路问题的核心算法及其典型应用场景，帮助读者建立完整的知识框架。

最短路问题的本质是在加权图中寻找两个顶点之间路径权值和最小的路径。根据图的性质（有无负权边、稀疏程度等），我们需要选择不同的算法：

Dijkstra算法：适用于无负权边的图，时间复杂度O((V+E)logV)（堆优化版本）
Bellman-Ford算法：能处理负权边，可检测负权环，时间复杂度O(VE)
Floyd-Warshall算法：计算所有顶点对的最短路，时间复杂度O(V³)
SPFA算法：Bellman-Ford的队列优化版本，平均O(E)，最坏O(VE)

实际应用中，90%的情况使用Dijkstra的堆优化版本就能解决问题。这也是为什么我在初学阶段就重点掌握了这个算法。

2. Dijkstra算法深度剖析与实现技巧

2.1 算法核心思想

Dijkstra算法采用贪心策略，每次从尚未确定最短路径的顶点中选择距离起点最近的一个，然后更新其邻接顶点的距离估计。这个过程需要维护一个优先队列（小根堆）来高效获取当前最小距离顶点。

cpp复制// 典型Dijkstra实现框架
void dijkstra(int s) {
    priority_queue<PII, vector<PII>, greater<PII>> pq;
    dist[s] = 0;
    pq.push({0, s});
    
    while (!pq.empty()) {
        auto [d, u] = pq.top(); pq.pop();
        if (vis[u]) continue;
        vis[u] = true;
        
        for (auto &[v, w] : adj[u]) {
            if (dist[v] > dist[u] + w) {
                dist[v] = dist[u] + w;
                pq.push({dist[v], v});
            }
        }
    }
}

2.2 关键实现细节

堆优化：使用STL的priority_queue时，注意默认是大根堆，需要传入greater参数变为小根堆
标记数组：vis数组用于记录已确定最短路的顶点，避免重复处理
距离初始化：dist数组初始值应为INF（足够大的数）
邻接表存储：稀疏图推荐使用vector<vector<pair<int, int>>>存储

2.3 常见错误与调试技巧

初学者常犯的错误包括：

忘记初始化距离数组
在无向图中只添加单向边
没有正确处理优先队列中的重复顶点
对负权边错误使用Dijkstra

调试时建议：

打印每次出队的顶点和距离
检查图的构建是否正确
对边界情况（如单顶点图）进行专门测试

3. 最短路问题的经典变形与应用

3.1 最长路问题

虽然Dijkstra不能直接求最长路，但可以通过以下方式解决：

全负权边：将边权取反，求最短路后再取反
DAG图：拓扑排序后动态规划
一般图：使用Bellman-Ford算法（可能检测到正权环）

cpp复制// 最长路转换示例
for (auto &e : edges) {
    e.w = -e.w;  // 边权取反
}
dijkstra(start);
longest_path = -dist[end];  // 结果取反

3.2 多源最短路问题

当需要计算所有顶点对之间的最短路时，Floyd-Warshall算法是最佳选择。其核心思想是动态规划：

cpp复制// Floyd-Warshall算法实现
for (int k = 1; k <= n; ++k)
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= n; ++j)
            dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);

3.3 次短路与k短路

次短路可以通过修改Dijkstra算法，同时维护到每个顶点的最短路和次短路。k短路则通常使用A*算法或Yen's算法。

4. 实战案例分析

4.1 字符顶点映射问题

当顶点不是数字而是字符时，需要建立映射关系。常见解决方案：

ASCII码转换：适用于有限字符集（如A-Z）
哈希映射：使用unordered_map或map建立字符串到整型的映射

cpp复制// 字符串顶点映射示例
unordered_map<string, int> node_map;
int get_id(const string &s) {
    if (!node_map.count(s)) {
        int id = node_map.size() + 1;
        node_map[s] = id;
    }
    return node_map[s];
}

4.2 正反向建图技巧

对于"去程+回程"类问题，可以通过正反向建图将多源单终点问题转化为单源最短路问题：

cpp复制// 正反向建图示例
vector<Edge> forward_edges, backward_edges;
// 构建正向图（去程）
build_graph(forward_edges);
dijkstra(forward_dist, start);
// 构建反向图（回程）
build_reverse_graph(backward_edges);
dijkstra(backward_dist, end);
// 结果计算
for (int i = 1; i <= n; ++i) {
    total[i] = forward_dist[i] + backward_dist[i];
}

4.3 网格图最短路问题

对于二维网格中的最短路问题，可以将每个网格点视为图中的一个顶点，相邻网格点之间建立边：

cpp复制// 网格图Dijkstra实现
struct Node {
    int x, y, dist;
    bool operator<(const Node &other) const {
        return dist > other.dist;  // 小根堆
    }
};

void grid_dijkstra(int start_x, int start_y) {
    priority_queue<Node> pq;
    pq.push({start_x, start_y, grid[start_x][start_y]});
    dist[start_x][start_y] = grid[start_x][start_y];
    
    while (!pq.empty()) {
        auto node = pq.top(); pq.pop();
        if (vis[node.x][node.y]) continue;
        vis[node.x][node.y] = true;
        
        for (int i = 0; i < 4; ++i) {
            int nx = node.x + dx[i], ny = node.y + dy[i];
            if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
            if (dist[nx][ny] > dist[node.x][node.y] + grid[nx][ny]) {
                dist[nx][ny] = dist[node.x][node.y] + grid[nx][ny];
                pq.push({nx, ny, dist[nx][ny]});
            }
        }
    }
}

5. 高级应用与优化技巧

5.1 最短路计数

计算最短路数量的关键在于发现：当找到一条更短的路径时，重置计数；当找到等长路径时，累加计数：

cpp复制if (dist[v] > dist[u] + w) {
    dist[v] = dist[u] + w;
    cnt[v] = cnt[u];  // 重置计数
    pq.push({dist[v], v});
} else if (dist[v] == dist[u] + w) {
    cnt[v] += cnt[u];  // 累加计数
    cnt[v] %= MOD;     // 可能需要取模
}