目录
二.堆优化版的Dijkstra算法（解决稀疏图）O(mlogn)
一.朴素Dijkstra算法（解决稠密图）O(n^2)
思路
1.用dist数组保存从源点到其他各个点的距离，dist[i]表示从源点到节点i的距离，初始化所有距离都为正无穷。用st状态数组记录是否找到从源点到i点的最短距离， 若为真则找到了，初始化数组元素都为假。
2.令dist[1] = 0, 因为从源点到源点的距离为0
3.进行n - 1次迭代（因为源点已经加入）
4.遍历 dist 数组，找到一个节点t，这个节点是：没有确定最短路径的节点中距离源点最近的点。此时就找到了源点到该节点的最短距离，st[t] 置为 1。
5.用t来更新其它点的距离。遍历 t 所有可以到达的节点 j，如果 dist[j] 大于 dist[t] 加上 t -> j 的距离，即 dist[j] > dist[t] + w[t][j] ，则更新 dist[j] = dist[t] + w[t][j]。
6.直到st数组全为真。（此时dist数组中保存着从源点到各个节点的最短距离）
代码
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 520, M = 100010; //稠密图
int dist[N], g[N][N], n, m;
bool st[N]; //判断当前点的最短距离是否确定
int dijkstra()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0; //源点距离为0
for (int i = 0; i < n; i ++) //剩n - 1个点要更新所以迭代n - 1次
{
int t = -1;
for (int j = 1; j <= n; j ++) //找到节点t
if (!st[j] && (t == -1 || dist[j] < dist[t]))
t = j;
st[t] = true;
for (int j = 1; j <= n; j ++) //用t来更新所有能更新的点
dist[j] = min(dist[j], dist[t] + g[t][j]);
}
if (dist[n] == 0x3f3f3f3f) return -1;
else return dist[n];
}
int main()
{
scanf("%d%d", &n, &m);
memset(g, 0x3f, sizeof g);
while (m --)
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
g[a][b] = min(g[a][b], c); //有重边则保留最短的一条边
}
printf("%d", dijkstra());
return 0;
}二.堆优化版的Dijkstra算法（解决稀疏图）O(mlogn)
思路
1. 一号点的距离初始化为零，其他点初始化成无穷大。
2. 将一号点放入堆(优先队列)中。
3. 不断循环，直到堆空。每一次循环中执行的操作为：
弹出堆顶（与朴素版diijkstra找到S外距离最短的点相同O(1)，并标记该点的最短路径已经确定）。与朴素版dijkstra相比优化了寻找最短距离
用该点更新临界点的距离，若更新成功就加入到堆中。
代码
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
typedef pair<int, int> PII;
const int N = 200010;
int n, m, dist[N];
int h[N], e[N], ne[N], w[N], idx;
bool st[N];
void add(int a, int b, int c)
{
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
int dijkstra()
{
memset(dist, 0x3f, sizeof dist);
priority_queue<PII, vector<PII>, greater<PII>> heap;
heap.push({0, 1});
dist[1] = 0;
while (heap.size())
{
PII t = heap.top();
heap.pop();
int ver = t.second, distance = t.first;
if (st[ver]) continue;
st[ver] = true;
for (int i = h[ver]; i != -1; i = ne[i])
{
int j = e[i];
if (dist[j] > dist[ver] + w[i])
{
dist[j] = dist[ver] + w[i];
heap.push({dist[j], j});
}
}
}
if (dist[n] == 0x3f3f3f3f) return -1;
else return dist[n];
}
int main()
{
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
while (m --)
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
printf("%d", dijkstra());
return 0;
}三.Bellman_Ford算法 O(nm)
解决有边数限制的最短路问题
思路：
其原理为连续进行松弛，在每次松弛时把每条边都更新一下，若在 n-1 次松弛后还能更新，则说明图中有负环，因此无法得出结果，否则就完成。
for 循环k次 （即最短路径不超过k条边）
for 循环所有边a, b, c（松弛操作）
dist[b] = min(dist[b], last[a] + c)
注意：last数组是上一次迭代后 dist数组的备份，由于是每个点同时向外出发，因此需要对 dist数组进行备份，若不进行备份会因此发生串联效应，影响到下一个点
853. 有边数限制的最短路
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你求出从 1 号点到 n 号点的最多经过 k 条边的最短距离，如果无法从 1 号点走到 n 号点，输出
impossible。注意：图中可能 存在负权回路 。
输入格式
第一行包含三个整数 n,m,kn,m,k。
接下来 mm 行，每行包含三个整数 x,y,z 表示存在一条从点 x 到点 y 的有向边，边长为 zz。
点的编号为 1∼n。
输出格式
输出一个整数，表示从 1 号点到 n 号点的最多经过 k 条边的最短距离。
如果不存在满足条件的路径，则输出
impossible。数据范围
1≤n,k≤500,
1≤m≤10000,
1≤x,y≤n，
任意边长的绝对值不超过 10000。输入样例：
3 3 1 1 2 1 2 3 1 1 3 3输出样例：
3
#include <bits/stdc++.h>
using namespace std;
const int N = 510, M = 10010;
struct Edge {
int a, b, w;
}edges[M];
int n, m, k; //边数限制为k
int dist[N], backup[N]; //backup为备份数组，防止串联
void bellman_ford()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
for (int i = 0; i < k; i ++)
{
memcpy(backup, dist, sizeof dist);
for (int j = 0; j < m; j ++)
{
auto e = edges[j];
int a = e.a, b = e.b, w = e.w;
dist[b] = min(dist[b], backup[a] + w);
//使用备份数组backup，避免给a更新后立马更新b, 防止b一次性最短路径就多了条边
}
}
}
int main()
{
cin >> n >> m >> k;
for (int i = 0; i < m; i ++)
scanf("%d%d%d", &edges[i].a, &edges[i].b, &edges[i].w);
bellman_ford();
if (dist[n] > 0x3f3f3f3f / 2) puts("impossible");
else printf("%d", dist[n]);
return 0;
}四.SPFA算法 O(km)(k为每个节点进入队列的次数)
注：最坏为O(nm)
思路
1.用dist数组保存从源点到其他各个点的距离，dist[i]表示从源点到节点i的距离，初始化所有距离都为正无穷，令dist[1] = 0, 因为从源点到源点的距离为0
2.建立一个队列，初始时队列里只有起始点，用st数组，标记点是否在队列中。队头不断出队，计算始点起点经过队头到其他点的距离是否变短，如果变短且被点不在队列中，则把该点加入到队尾。
3.重复执行直到队列为空。
若一条路径上边数大于等于点数，则该路径一定存在负环
851. spfa求最短路
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出
impossible。数据保证不存在负权回路。
输入格式
第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 x,y,z 表示存在一条从点 x 到点 y 的有向边，边长为 z。
输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。
如果路径不存在，则输出
impossible。数据范围
1≤n,m≤105,
图中涉及边长绝对值均不超过 10000。输入样例：
3 3 1 2 5 2 3 -3 1 3 4输出样例：
2
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, m;
int h[N], e[N], w[N], ne[N], idx;
int dist[N];
bool st[N]; //提高效率，避免重复入队
void add(int a, int b, int c)
{
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
void spfa()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
queue<int> q;
q.push(1);
st[1] = true;
while (q.size())
{
int t = q.front();
q.pop();
st[t] = false; //t出队后，更新st的状态
for (int i = h[t]; ~i; i = ne[i])
{
int j = e[i];
if (dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
if (! st[j])
{
q.push(j);
st[j] = true;
}
}
}
}
}
int main()
{
cin >> n >> m;
memset(h, -1, sizeof h);
while (m --)
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
spfa();
if (dist[n] == 0x3f3f3f3f) cout << "impossible";
else cout << dist[n];
return 0;
}852. spfa判断负环
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你判断图中是否存在负权回路。
输入格式
第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
输出格式
如果图中存在负权回路，则输出
Yes，否则输出No。数据范围
1≤n≤2000,
1≤m≤10000,
图中涉及边长绝对值均不超过 10000。输入样例：
3 3 1 2 -1 2 3 4 3 1 -4输出样例：
Yes
#include <bits/stdc++.h>
using namespace std;
const int N = 2010, M = 10010;
int n, m;
int h[N], e[M], w[M], ne[M], idx;
int dist[N], cnt[N]; //cnt记录每个点到起点的边数
bool st[N];
void add(int a, int b, int c)
{
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
bool spfa()
{
//无需初始化dist数组，因为若存在负环，dist为0也会被更新
queue<int> q;
//若只加入节点1，则判断的是从1出发的路径上有无负环
for (int i = 1; i <= n; i ++) //1可能与负环回路不连通，所以要将全部点加入
{
st[i] = true;
q.push(i);
}
while (q.size())
{
int t = q.front();
q.pop();
st[t] = false;
for (int i = h[t]; ~i; i = ne[i])
{
int j = e[i];
if (dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
cnt[j] = cnt[t] + 1; //更新当前路径上的边数
if (cnt[j] >= n) return true; //若该路径上边数大于等于点数，则存在负环
if (! st[j])
{
st[j] = true;
q.push(j);
}
}
}
}
return false;
}
int main()
{
cin >> n >> m;
memset(h, -1, sizeof h);
while(m --)
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
if (spfa()) puts("Yes");
else puts("No");
return 0;
}五.Floyd算法 O(n^3)
思路
三层循环 （基于动态规划）
d[k][i][j]表示所有从i出发，最终走到j，且中间只经过节点编号不超过k的所有路径
d[i][j] = min(d[i][j], d[i][k]+d[k][j])
代码
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 210, INF = 1e9;
int n, m, q;
int d[N][N];
void floyd()
{
for (int k = 1; k <= n; k ++)
for (int i = 1; i <= n; i ++)
for (int j = 1; j <= n; j ++)
d[i][j] = min(d[i][j], d[i][k]+d[k][j]);
}
int main()
{
cin >> n >> m >> q;
for (int i = 1; i <= n; i ++)
for (int j = 1; j <= n; j ++)
if (i == j) d[i][j] = 0;
else d[i][j] = INF;
while (m --)
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
d[a][b] = min(d[a][b], c);
}
floyd();
while (q --)
{
int x, y;
scanf("%d%d", &x, &y);
if (d[x][y] > INF/2) puts("impossible");
else cout << d[x][y] << endl;
}
}
229
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
