最短路径算法是图论中的基础问题，旨在找到图中两个顶点之间的路径，使得路径上的边权之和
最小。在
C++ 中，常用的
最短路径算法包括 **Dijkstra 算法**、**Bellman-Ford 算法**、**
SPFA 算法** 和 **Floyd-Warshall 算法**。以下将分别介绍这些算法的基本思想及其实现方式，并提供对应的
C++ 示例代码。
### Dijkstra 算法
Dijkstra 算法适用于 **无负权边** 的图，常用于
单源最短路径问题。该算法通过贪心策略逐步找到从起点到其他所有顶点的
最短路径。
```cpp
#include <bits/std
c++.h>
using namespace std;
const int maxn = 105, inf = 0x3f3f3f3f;
struct edge {
int v, w;
};
vector<edge> e[maxn];
int dis[maxn], vis[maxn];
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> q;
void dijkstra(int n, int s) {
memset(dis, 0x3f, sizeof(dis));
memset(vis, 0, sizeof(vis));
dis[s] = 0;
q.emplace(0, s);
while (!q.empty()) {
int u = q.top().second;
q.pop();
if (vis[u]) continue;
vis[u] = true;
for (auto &ed : e[u]) {
int v = ed.v, w = ed.w;
if (dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
q.emplace(dis[v], v);
}
}
}
}
```
###
SPFA 算法
SPFA（Shortest Path Faster Algorithm）是 Bellman-Ford 算法的优化版本，适用于 **存在负权边** 的图。它使用队列优化，减少不必要的松弛操作。
```cpp
#include <bits/std
c++.h>
using namespace std;
const int maxn = 10001;
const long long INF = 2147483647;
int dis[maxn];
int vis[maxn];
int n, m, s;
struct node {
int s1;
int side;
};
vector<node> mp[maxn];
void init() {
for (int i = 1; i <= n; i++) {
dis[i] = INF;
vis[i] = 0;
}
}
void
Spfa(int s) {
queue<int> v;
vis[s] = 1;
v.push(s);
dis[s] = 0;
while (!v.empty()) {
int q = v.front();
v.pop();
vis[q] = 0;
for (int i = 0; i < mp[q].size(); i++) {
if (dis[mp[q][i].s1] > dis[q] + mp[q][i].side) {
dis[mp[q][i].s1] = dis[q] + mp[q][i].side;
if (vis[mp[q][i].s1]) {
continue;
}
v.push(mp[q][i].s1);
}
}
}
}
```
### Floyd-Warshall 算法
Floyd-Warshall 算法用于 **多
源最短路径问题**，即求图中任意两个顶点之间的
最短路径。它适用于 **稠密图**，时间复杂度为 $ O(n^3) $。
```cpp
#include <bits/std
c++.
扫一扫
511
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
