1. 单源最短路径问题概述
单源最短路径（Single-Source Shortest Path，SSSP）是图论中的经典问题，指在带权图中从某个固定起点出发，计算到达图中所有其他顶点的最短路径及其权值之和。这个问题在现实生活中有着广泛的应用场景，比如：
- 导航系统中的路线规划
- 网络路由协议中的最优路径选择
- 社交网络中的关系链分析
- 物流配送中的最优运输路线
在算法竞赛中，单源最短路径问题更是常客，几乎每场大型比赛都会出现相关题目。根据图的不同特性（如边权是否可为负、是否存在负权环、图的稠密程度等），我们需要选择不同的算法来高效解决问题。
2. 常见最短路算法对比分析
2.1 Bellman-Ford算法：最基础的松弛思想
Bellman-Ford算法是最直接的最短路算法，其核心思想是通过反复松弛（relaxation）操作来逐步逼近最短路径。算法流程如下：
- 初始化：将起点到自身的距离设为0，到其他所有点的距离设为无穷大
- 进行n-1轮松弛操作（n为顶点数）
- 每轮对所有边进行松弛：对于边(u,v,w)，如果dist[u]+w < dist[v]，则更新dist[v]
cpp复制// Bellman-Ford算法核心代码
for (int i = 1; i <= n-1; ++i) {
bool updated = false;
for (auto &edge : edges) {
int u = edge.u, v = edge.v, w = edge.w;
if (dist[u] != INF && dist[v] > dist[u] + w) {
dist[v] = dist[u] + w;
updated = true;
}
}
if (!updated) break; // 提前终止优化
}
时间复杂度分析：
- 最坏情况：O(n*m)，其中n是顶点数，m是边数
- 优点：可以处理负权边，并能检测负权环
- 缺点：对于大规模图（如n=1e5）效率极低
2.2 SPFA算法：队列优化的Bellman-Ford
SPFA（Shortest Path Faster Algorithm）本质上是Bellman-Ford的队列优化版本，通过只处理那些可能产生更新的节点来提高效率。
算法流程：
- 初始化距离数组，起点入队
- 取出队首节点u，遍历其所有邻接边(u,v,w)
- 如果dist[v] > dist[u] + w，则更新dist[v]并将v入队（如果不在队列中）
- 重复直到队列为空
cpp复制// SPFA核心代码
queue<int> q;
q.push(s);
in_queue[s] = true;
while (!q.empty()) {
int u = q.front(); q.pop();
in_queue[u] = false;
for (auto &edge : adj[u]) {
int v = edge.v, w = edge.w;
if (dist[v] > dist[u] + w) {
dist[v] = dist[u] + w;
if (!in_queue[v]) {
q.push(v);
in_queue[v] = true;
}
}
}
}
时间复杂度分析：
- 平均情况：O(k*m)，其中k是常数，通常在随机图上表现优秀
- 最坏情况：O(n*m)，可能被特殊构造的数据卡掉
- 优点：在随机图上效率高，能处理负权边
- 缺点：不稳定，竞赛中不建议使用
重要提示：在算法竞赛中，除非题目明确要求处理负权边，否则不建议使用SPFA。很多出题人会特意构造数据使SPFA退化为O(n*m)复杂度。
2.3 Dijkstra算法：非负权图的最优解
Dijkstra算法是解决非负权图单源最短路径问题的最优选择。其核心思想是贪心算法，每次选择当前距离起点最近的未确定节点，确定其最短路径，并用它来更新邻居。
2.3.1 原始Dijkstra实现
cpp复制// 原始Dijkstra伪代码
while (存在未确定的节点) {
u = 未确定的节点中dist最小的
标记u为已确定
for (u的每个邻居v) {
if (dist[v] > dist[u] + w(u,v)) {
dist[v] = dist[u] + w(u,v)
}
}
}
时间复杂度：
- 使用普通数组存储：O(n^2)
- 适用于稠密图（m接近n^2）
2.3.2 堆优化Dijkstra实现
对于稀疏图（m远小于n^2），我们可以用优先队列（堆）来优化寻找最小dist节点的过程。
cpp复制// 堆优化Dijkstra核心代码
priority_queue<pair<int, int>> pq; // (-dist, node)
pq.push({0, s});
while (!pq.empty()) {
auto [d, u] = pq.top(); pq.pop();
d = -d;
if (vis[u]) continue;
vis[u] = true;
for (auto &edge : adj[u]) {
int v = edge.v, w = edge.w;
if (dist[v] > dist[u] + w) {
dist[v] = dist[u] + w;
pq.push({-dist[v], v});
}
}
}
时间复杂度分析：
- 每个节点最多入队一次，每次堆操作O(log n)
- 总复杂度：O(m log n)
- 优点：稳定高效，适合大规模稀疏图
- 缺点：不能处理负权边
3. 堆优化Dijkstra的完整实现与优化技巧
3.1 邻接表存储图结构
对于大规模图（n=1e5），我们需要使用邻接表而非邻接矩阵来存储图，以节省空间。
cpp复制struct Edge {
int v, w;
};
vector<Edge> adj[MAXN]; // 邻接表
// 添加边
void add_edge(int u, int v, int w) {
adj[u].push_back({v, w});
}
3.2 优先队列的实现细节
C++的priority_queue默认是最大堆，我们需要通过存储负值或自定义比较函数来实现最小堆。
cpp复制// 方法1：存储负距离
priority_queue<pair<int, int>> pq; // (-dist, node)
pq.push({-dist[s], s});
// 方法2：自定义比较函数
struct Node {
int u, d;
bool operator<(const Node &rhs) const {
return d > rhs.d; // 小根堆
}
};
priority_queue<Node> pq;
3.3 完整代码实现
cpp复制#include <iostream>
#include <vector>
#include <queue>
#include <cstring>
using namespace std;
const int MAXN = 1e5 + 5;
const int INF = 0x3f3f3f3f;
struct Edge {
int v, w;
};
vector<Edge> adj[MAXN];
int dist[MAXN];
bool vis[MAXN];
void dijkstra(int s, int n) {
memset(dist, 0x3f, sizeof(dist));
memset(vis, 0, sizeof(vis));
dist[s] = 0;
priority_queue<pair<int, int>> pq; // (-dist, node)
pq.push({0, s});
while (!pq.empty()) {
auto [d, u] = pq.top(); pq.pop();
d = -d;
if (vis[u]) continue;
vis[u] = true;
for (auto &edge : adj[u]) {
int v = edge.v, w = edge.w;
if (dist[v] > dist[u] + w) {
dist[v] = dist[u] + w;
pq.push({-dist[v], v});
}
}
}
}
int main() {
int n, m, s;
cin >> n >> m >> s;
for (int i = 0; i < m; ++i) {
int u, v, w;
cin >> u >> v >> w;
adj[u].push_back({v, w});
}
dijkstra(s, n);
for (int i = 1; i <= n; ++i) {
if (dist[i] == INF) cout << "INF ";
else cout << dist[i] << " ";
}
return 0;
}
3.4 常见优化技巧
-
提前终止：如果只需要计算到特定终点的最短路径，可以在该点出队时立即终止算法。
-
双队列优化：对于某些特定图结构，可以使用双队列（一个普通队列和一个优先队列）来减少堆操作次数。
-
SLF优化：在SPFA中可以使用Small Label First策略，将更小的dist节点放在队列前端。
-
内存优化：对于极大图，可以使用更紧凑的邻接表实现，如链式前向星。
4. 算法选择与竞赛实战建议
4.1 不同场景下的算法选择
| 算法 | 时间复杂度 | 适用场景 | 能否处理负权 | 竞赛建议 |
|---|---|---|---|---|
| Bellman-Ford | O(n*m) | 小规模图，需要检测负权环 | 是 | 仅用于教学目的 |
| SPFA | O(km)~O(nm) | 含负权边但无负权环的图 | 是 | 不推荐使用 |
| Dijkstra | O(m log n) | 非负权图 | 否 | 首选算法 |
| Floyd-Warshall | O(n^3) | 全源最短路，小规模图 | 是 | n<500时考虑 |
4.2 竞赛中的注意事项
-
仔细阅读题目条件：确认图中是否可能有负权边或负权环。
-
数据规模分析：根据n和m的范围选择合适的算法：
- n≤1e3, m≤1e4：原始Dijkstra或SPFA
- n≤1e5, m≤2e5：必须使用堆优化Dijkstra
-
初始化与边界处理：
- 距离数组初始化为足够大的值（如0x3f3f3f3f）
- 注意起点到自身的距离为0
- 处理不可达情况
-
优先使用邻接表：大规模图必须使用邻接表存储，避免MLE。
-
禁用SPFA：除非题目明确要求处理负权边，否则一律使用Dijkstra。
4.3 常见错误与调试技巧
-
无限循环：检查优先队列是否正确处理了重复节点（通过vis数组）。
-
错误的最短路径：
- 确认边权是否为非负
- 检查松弛条件是否正确实现
- 验证图的存储是否正确（特别是边的方向）
-
性能问题：
- 确保使用堆优化而非原始Dijkstra
- 检查是否有不必要的拷贝操作
- 使用更快的IO方法（如scanf/printf或关闭cin同步）
-
内存问题：
- 对于极大图，考虑使用更紧凑的数据结构
- 检查数组大小是否足够（通常开n+5）
5. 扩展与变种问题
5.1 带限制的最短路径问题
在实际问题中，我们经常需要在满足某些约束条件下求最短路径，比如：
- 次短路径：维护到每个点的最短和次短距离
- k短路问题：使用A*或Yen's算法
- 边数限制的最短路径：Bellman-Ford的变种
5.2 多权值最短路
当每条边有多个权值（如距离和时间）时，可以：
- 转化为单权值：通过加权求和或其他方式合并多个权值
- 分层图技术：将不同权值的影响建模到图的不同层次中
- Pareto最优解：寻找所有不被其他路径全面超越的路径
5.3 动态最短路问题
对于图结构会动态变化的情况，可以考虑：
- 增量更新算法：当图发生小变化时，基于之前结果快速更新
- 动态规划结合：对于特定类型的动态变化，可以使用DP思想
- 预处理与查询分离：如使用Contraction Hierarchies等技术
在实际编程竞赛中，最常考察的还是标准的单源最短路问题。掌握好堆优化Dijkstra的实现细节和应用场景，就能解决大部分相关问题。对于更复杂的最短路变种，建议在熟练掌握基础算法后再进行深入学习。