最短路算法模板总结

图论当中将图为有向图和无向图，这里只考虑有向图的算法。对于无向图，我们将其看做是一种特殊的有向图，对所有的无向边u↔vu \leftrightarrow vu↔v都看做是u→vu\to vu→v和v→uv \to uv→u。

约定：nnn表示图中点数，mmm表示图中边数。

稠密图：mmm 与 n2n^2n2数量级大致相同

稀疏图：mmm 和 nnn数量级大致相同

建图

一般常用的建图方式有两种：

邻接矩阵：定义二维数组 g[N][N]g[N][N]g[N][N]，g[i][j]g[i][j]g[i][j]表示点iii和jjj之间的边权。
邻接表：数组模拟邻接表，为每个节点开一个单链表，分别存储该点的所有邻接边。

特殊的，对于Bellman_ford算法，我们通常定义结构体数组存储所有边的信息。

最短路算法

最短路算法一般分为两类：

单源最短路，常见的算法有：

(1)(1)(1)Dijkstra：只有所有边的边权为正才可以使用，在稠密图中的算法时间复杂度为O(n2)为O(n^2)为O(n2)，在稀疏图中的算法时间复杂度为O(m×long(n))O(m\times long(n))O(m×long(n))。

(2)(2)(2)Bellman_ford：存在负权边时使用，有边数限制的最短路问题，存在负权回路时的最短路问题，时间复杂度为O(nm)O(nm)O(nm)。

(3)(3)(3)spfa—队列优化的Bellman_ford算法：时间复杂度为O(m)O(m)O(m)，时间复杂度最坏为O(nm)O(nm)O(nm)。
多源最短路：

(1)(1)(1)Floyd：标准弗洛伊德算法，三重循环。循环结束之后 d[i][j]d[i][j]d[i][j]存储的就是点 iii 到点 jjj 的最短距离。需要注意循环顺序不能变：第一层枚举中间点，第二层和第三层枚举起点和终点。时间复杂度O(n3)O(n^3)O(n3)。

Dijkstra算法模板（包括堆优化）

朴素Dijkstra

#include <iostream>
#include <cstring>
#include <algorithm>using namespace std;const int N = 510, INF = 0x3f3f3f3f;int n, m;
int g[N][N];
int dist[N];
bool st[N]; // 确定最短路点的集合void dijkstra()
{memset(dist, 0x3f, sizeof dist);dist[1] = 0;for(int i = 0; i < n; i ++){int t = -1;for(int j = 1; j <= n; j ++) // 找距离最小点来更新其他点if(!st[j] && (t == -1 || dist[t] > dist[j]))t = j;// 更新其他点for(int j = 1; j <= n; j ++)dist[j] = min(dist[j], dist[t] + g[t][j]);// 标记已确定最短路的点st[t] = true;}
}int main()
{cin >> n >> m;for(int i = 1; i <= n; i ++)for(int j = 1; j <= n; j ++)if(i == j) g[i][j] = 0;else g[i][j] = INF;while (m -- ){int a, b, c;scanf("%d%d%d", &a, &b, &c);g[a][b] = min(g[a][b], c);}dijkstra();if(dist[n] == INF) puts("-1");else printf("%d\n", dist[n]);return 0;
}

堆优化版dijkstra

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>using namespace std;const int N = 150010, INF = 0x3f3f3f3f;typedef pair<int, int> PII;int n, m;
int h[N], e[N], ne[N], w[N], idx;
int dist[N];
bool st[N]; // 被确定最短路的点集合void add(int a, int b, int c)
{ e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx ++;
}void dijkstra()
{memset(dist, 0x3f, sizeof dist);dist[1] = 0;priority_queue<PII, vector<PII>, greater<PII>> heap;heap.push({0, 1});while(heap.size()){auto t = heap.top();heap.pop();int ver = t.second;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];// d[ver] 是当前最小点的距离; w[i] 是当前邻接边的权重heap.push({dist[j], j});}}}
}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);}dijkstra();if(dist[n] == INF) puts("-1");else printf("%d\n", dist[n]);return 0;
}

Bellman_Ford算法模板

Bellman_Ford

解决有限制边数的最短路问题必须选择Bellman_Ford

#include <iostream>
#include <cstring>
#include <algorithm>using namespace std;const int N = 510, M = 10010, INF = 0x3f3f3f3f;struct Edge
{int a, b, w;
}edges[M];int n, m, k;
int dist[N], backup[N];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 ++){int a = edges[j].a, b = edges[j].b, w = edges[j].w;dist[b] = min(dist[b], backup[a] + w);}}
}int main()
{cin >> n >> m >> k;for(int i = 0; i < m; i ++){int a, b, w;scanf("%d%d%d", &a, &b, &w);edges[i] = {a, b, w};}Bellman_Ford();if(dist[n] > INF / 2) puts("impossible");else printf("%d\n", dist[n]);return 0;
}

spfa（队列优化Bellman_Ford）算法模板

spfa算法求解最短路

spfa算法与堆优化Dijkstra算法类似，在一般情况下spfa巨快

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>using namespace std;const int N = 100010, INF = 0x3f3f3f3f;int n, m;
int h[N], e[N], ne[N], w[N], idx;
int dist[N];
bool st[N];void add(int a, int b, int c)
{e[idx] = b, ne[idx] = h[a], w[idx] = c, 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;for(int i = h[t]; i != -1; i = ne[i]){int j = e[i];if(dist[j] > dist[t] + w[i]){dist[j] = dist[t] + w[i];if(!st[j]){st[j] = true;q.push(j);}}}}
}int main()
{cin >> n >> m;memset(h, -1, sizeof h);while (m -- ){int a, b, w;scanf("%d%d%d", &a, &b, &w);add(a, b, w);}spfa();if(dist[n] > INF / 2) puts("impossible");else printf("%d\n", dist[n]);return 0;
}

Floyd算法模板

Floyd算法模板题

#include <iostream>
#include <cstring>
#include <algorithm>using namespace std;const int N = 210, INF = 0x3f3f3f3f;int g[N][N];
int n, m, Q;void floyd()
{for(int k = 1; k <= n; k ++)for(int i = 1; i <= n; i ++)for(int j = 1; j <= n; j ++)g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
}int main()
{scanf("%d%d%d", &n, &m, &Q);for(int i = 1; i <= n; i ++)for(int j = 1; j <= n; j ++)if(i == j) g[i][j] = 0;else g[i][j] = INF;while(m --){int a, b, c;scanf("%d%d%d", &a, &b, &c);g[a][b] = min(g[a][b], c);}floyd();while(Q --){int x, y;scanf("%d%d", &x, &y);if(g[x][y] > INF / 2) puts("impossible");else printf("%d\n", g[x][y]);}return 0;
}

最短路算法模板（Dijkstra、Bellman_ford、spfa、Floyd）相关推荐

详解最短路算法模板(dijkstra+floyd+spfa)
1.Floyd_Warshall算法核心思路:d[i][j] = min{d[i][j], d[i][k] + d[k][j]} 从i到j有两种路径,经过k点或是不经过k点,所以我们枚举k即可求所有 ...
【最短路算法】dijkstra，SPFA和folyd
在了解本知识点之前,首先要了解图的建立,也就是邻接表和邻接矩阵. 邻接矩阵适用于稠密图邻接表适用于稀疏图目录单源最短路问题 dijkstra算法 SPFA算法 folyd算法最小生成树拓扑排 ...
【阿良的算法之路】图论最短路算法模板
图论: [阿良的算法之路]图论最短路算法模板 [模板]dirjkstra单源最短路径 [模板]Bellman-Ford多源最短路 [模板]Spfa求最短路 [模板]Spfa判断负环 [模板]Floya ...
四大算法解决最短路径问题（Dijkstra+Bellman-ford+SPFA+Floyd）
什么是最短路径问题? 简单来讲,就是用于计算一个节点到其他所有节点的最短路径. 单源最短路算法:已知起点,求到达其他点的最短路径. 常用算法:Dijkstra算法.Bellman-ford算法.SPF ...
疯子的算法总结(八) 最短路算法+模板
Dijkstra:适用于权值为非负的图的单源最短路径,用斐波那契堆的复杂度O(E+VlgV) BellmanFord:适用于权值有负值的图的单源最短路径,并且能够检测负圈,复杂度O(VE) SPFA: ...
算法基础14 —— 图论入门之弗洛伊德算法(Floyed + Dijkstra + Bellman-Ford + SPFA)
入门概念带权图:如下图所示,我们把边带有权值的图称为带权图可以将边的权值理解为两点之间的距离一张图中任意两点间会有不同的路径相连最短路径:最短路径就是指连接两点的这些路径中最短的一条 Floy ...
ACM-ICPC 2018 沈阳赛区网络预赛 D. Made In Heaven （K短路算法模板）
题意 : 求第k短路的权值是否超过T(权值) 解法: 网上随便找的一个求K短路的算法模板套弄一下即可 (模板要好,不然邻接表存图会TLE , 网上换了两个模板才AC的) AC代码: #include& ...
最短路算法模板--SPFA
初见SPFA时,直接认成了优先队列优化的Dijkstra,经过几位大佬的指点,我终于明白了他们的差异. Dijkstra是保证已经出队过的点不再入队,SPFA是已经在队列中不再入队.比较起来,SPFA ...
图的最短路算法（Dijkstra和Floyd-Warshall）
一.单源最短路(Dijkstra算法) 基本思想选定一个源点,按路径长度递增次序,逐步产生最短路径(贪心),直到此源点到其他各顶点的最短路径全部求出为止. 数据结构带权有向图G=(V,E),V = ...
最短路合集（Dijkstra、SPFA、Floyd以及路径还原模板）
目录一.Dijkstra算法(不能处理存在负权的清况) 1.堆(优先队列)优化版本:(慢,占用内存还大) 2.普通线段树优化版本(一般块) 2.大佬的特殊线段树优化版本:(超快的) 二.SPFA 算 ...

最短路算法模板（Dijkstra、Bellman_ford、spfa、Floyd）