最短路问题

图的存储

一、单源最短路

① 朴素Dijkstra O(n^2)

练习题

代码

② 堆优化Dijkstra O(mlogn)

练习题

代码

③ Bellman_ford O(nm)

练习题

代码

④ Spfa O(n) - O(nm)

练习题

代码

二、多源最短路

Floyd O(n^3)

练习题

代码

最短路问题

图的存储

稠密图(边数很大，点数很少)用邻接矩阵存储，邻接矩阵即开辟一个二维数组，g[a][b]代表a到b有一条边

稀疏图(边数与点数差不多)用邻接表存储，邻接表为链表数组，代码如下：

const int N = 1e5+5;
int h[N], e[N], ne[N], idx;

一、单源最短路

单源指的是只能从一个结点出发

① 朴素Dijkstra O(n^2)

稠密图(邻接矩阵存储)常用：此时点数较小，n*n不会超时间限制,时间复杂度为

步骤：

初始化距离数组和邻接矩阵，dist[1] = 0，dist[i] = 0x3f3f3f3f，g[i] [j] = 0x3f3f3f3f
for外循环n(或者n-1)次遍历，再一层for循环遍历距离数组获取不在S数组里的离源点最短的点t
用t更新其他的点，把t加到S集合中

练习题

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为正值。

请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1。

输入格式

第一行包含整数 n 和 m。

接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出格式

输出一个整数，表示 1 号点到 n 号点的最短距离。

如果路径不存在，则输出 −1。

数据范围

1≤n≤500,
1≤m≤105,
图中涉及边长均不超过10000。

输入样例：
3 3
1 2 2
2 3 1
1 3 4
输出样例：
3

代码

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int N=505;
// g是邻接矩阵，因为题目数据是结点数500，边数10000，为稠密图，所以用邻接矩阵存储
//dist存放的是所有点到源点的最短距离
int g[N][N], dist[N];
//st数组是state，表示该点是否已经确定为最短路径点
bool st[N];
int n,m;
int dijkstra() {memset(dist, 0x3f, sizeof dist );dist[1] = 0;//第n个结点的到源点的最短路需要经过n步完成，也即确定前面n-1个点的最短路径，第n个结点才会是最短路径for(int i = 0; i < n ; i ++) {int t = -1; //dijkstra算法应用于无负权值的图//遍历每个点，找出目前为止离源点最近且还没确定最短路径的点for(int j = 1; j <= n; j ++) {//t等于-1确保至少第一个还没确定的点会被选中，dist[t] > dist[j]是更新t为未确定的最短的点if(!st[j] && (t == -1 || dist[t] > dist[j]))t = j;}/*这一步其实做了一些无用功，因为这一步实际上是遍历t所有可以到达的点并更新，但是t一般不会连接其余所有的点，但是g被我们初始化为最大，又是取min，所以没有影响。且在t前面已经有一些点被确定最短了，这些点也就不会被更新了。*/for(int j = 1; j <= n; j ++)    dist[j] = min(dist[j], dist[t] + g[t][j]);st[t] = true;}// 如果n仍然为0x3f3f3f3f代表着没有到n的最短路径。if(dist[n] == 0x3f3f3f3f) return -1;return dist[n];
}
int main() {cin >> n >> m;int a, b, c;memset(g, 0x3f, sizeof g); //每个点之间的权值初始化为最大while(m--) {scanf("%d%d%d",&a,&b,&c);g[a][b] = min(g[a][b], c); //有重边取最小权值}cout << dijkstra() << endl;return 0;
}

② 堆优化Dijkstra O(mlogn)

稀疏图(邻接表存储)常用：此时点数较大，如果用朴素Dijkstra会超时，利用小根堆优化找dist数组中最小的未加入S集合的点，时间复杂度为

步骤

初始化距离数组和邻接表，dist[1] = 0，dist[i] = 0x3f3f3f3f，h[i] = -1
初始化小根堆，将{0， 1}放入堆，每次取出堆顶元素
如果被确定就跳过，否则加入S集合并更新其他点，被更新的点也要加入堆中进行下一次更新

练习题

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为非负值。

请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1。

输入格式

第一行包含整数 n 和 m。

接下来 mm 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出格式

输出一个整数，表示 1 号点到 nn 号点的最短距离。

如果路径不存在，则输出 −1。

数据范围

1≤n,m≤
图中涉及边长均不小于 0，且不超过 10000。
数据保证：如果最短路存在，则最短路的长度不超过。

输入样例：
3 3
1 2 2
2 3 1
1 3 4
输出样例：
3

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
typedef pair<int ,int > PII;
const int N=1e6+5;
//稀疏图用邻接表存储，w为权重数组
int e[N],ne[N],w[N],dist[N],h[N],idx,n, m;
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);dist[1] = 0;priority_queue<PII, vector<PII>, greater<PII> > p;//first代表距离，second代表点p.push({0, 1});while(p.size()) {//这一步相当于之前for循环遍历拿出dist中距离源点的最短距离的点auto t = p.top();//弹出p.pop();//ver为点， distance为到源点的距离int ver = t.second, distance = t.first;//如果这个点已经确定了那就跳过if(st[ver]) continue;st[ver] = true;//更新与该点相连的其它点的distfor(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];p.push({dist[j], j});}}}if(dist[n] == 0x3f3f3f3f) return -1;return dist[n];
}
int main() {int a, b ,c;cin >> n >> m;// 初始化链表数组头节点memset(h, -1, sizeof h);while(m--) {scanf("%d%d%d", &a, &b, &c);add(a,b,c);}cout << dijkstra() << endl;return 0;
}

注意：以上两种只适用于正权图

③ Bellman_ford O(nm)

Bellman - ford 算法是求含负权图的单源最短路径的一种算法，效率较低，代码难度较小。其原理为连续进行松弛，在每次松弛时把每条边都更新一下，若在 n-1 次松弛后还能更新，则说明图中有负环，因此无法得出结果，否则就完成。
(通俗的来讲就是：假设 1 号点到 n 号点是可达的，每一个点同时向指向的方向出发，更新相邻的点的最短距离，通过循环 n-1 次操作，若图中不存在负环，则 1 号点一定会到达 n 号点，若图中存在负环，则在 n-1 次松弛后一定还会更新)

dijkstra为什么不能应用于负权值的边
首先我们要知道为什么dijkstra算法不能应用于有负权边得图中，因为dijkstra算法更新的时候是每次外循环都直接确定一个点为最短路径，一棒子打死，后面如果有负权边走到该点并且距离源点得距离才是最远的也更新不了了

存储结构
Bellman_ford用结构体简单存储即可，存下的是点对点以及权值，也即每条边以及其权值

稀疏图常用，直接使用结构体存储边的两端点和权值,时间复杂度为

步骤

初始化距离数组，dist[1] = 0，dist[i] = 0x3f3f3f3f
for外循环k次，备份dist的备份数组backup
内循环遍历所有的边，松弛dist[x.b] = min(dist[x.b], backup[x.a]+x.w);
判断是否有无最短路径到达n，一般是dist[n] > 0x3f3f3f3f / 2，具体看题目对于边的大小范围

为什么要备份呢，因为可能出现串联，也就是在一次更新中，前面已经更新的数据影响了后面的数据

此时的3会因为前面的2已经变化为1而更新成2，所以我们用上一次迭代的dist数组也就是backup来更新

练习题

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你求出从 1 号点到 n 号点的最多经过 k 条边的最短距离，如果无法从 1 号点走到 n 号点，输出 impossible。

注意：图中可能 存在负权回路 。

输入格式

第一行包含三个整数 n,m,k。

接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。

点的编号为 1∼n。

输出格式

输出一个整数，表示从 1 号点到 nn 号点的最多经过 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<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int N=505, M=1e5+5;
int dist[N], backup[N], n,m,k;
struct Edge {int a, b, w;
}edge[M]; //边集，用结构体存储
void bellman_ford() {memset(dist, 0x3f, sizeof dist);dist[1] = 0;for(int i = 0; i < k; i ++ ) {//有可能出现串联，所以需要先备份一份memcpy(backup, dist, sizeof dist);//通过遍历边数组不断更新每个点的最短值，不同于dijkstra算法的一板子拍死，每次都更新全部//以上一次更新k-1条边的backup数组为基础来更新，每次都取最小值，因此可以找出有无到达的最短值for(int j = 0; j < m; j ++ ) {int a = edge[j].a, b = edge[j].b, w = edge[j].w;dist[b] = min(dist[b], backup[a] + w);}}return ;
}
int main() {int a,b,w;cin >> n >> m >> k;for(int i=0;i<m;i++) {scanf("%d%d%d", &a, &b, &w);edge[i]={a,b,w};}bellman_ford();//根据具体题目来制定判断，题目的点数为500，每条边最大为10000，也就是最多会减500万//那么如果n大于0x3f3f3f3f / 2就意味着dist[n]没有被更新过if(dist[n] >= 0x3f3f3f3f / 2) cout << "impossible" << endl;else cout << dist[n] << endl;return 0;
}

④ Spfa O(n) - O(nm)

spfa是基于Bellman_ford优化的，在松弛的时候并不是每条边都需要更新，因此我们利用队列优化，将真正需要更新的点放入队列中，bellman_ford算法中，只有backup[a]被更新过，dist[b]才需要进行更新，所以当一个点被更新时就放入队列。简而言之：我更新过谁，我就把谁放入队列，时间复杂度为

步骤

是否初始化dist都可以，dist[1] = 0，dist[i] = 0x3f3f3f3f
每次取出队首元素进行更新，用st数组标记点是否在队列中，如果在的话无需重复添加
如果需要辨别是否有负权环的存在，使用cnt数组记录每个点的入队次数，>=n次则证明存在

练习题

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 impossible。

数据保证不存在负权回路。

输入格式

第一行包含整数 n 和 m。

接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出格式

输出一个整数，表示 1 号点到 n 号点的最短距离。

如果路径不存在，则输出 impossible。

数据范围

1≤n,m≤
图中涉及边长绝对值均不超过 10000。

输入样例：
3 3
1 2 5
2 3 -3
1 3 4
输出样例：
2

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
typedef pair<int ,int > PII;
const int N=1e6+5;
//稀疏图用邻接表存储，w为权重数组
int e[N],ne[N],w[N],dist[N],h[N],idx,n, m;
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 spfa() {memset(dist, 0x3f, sizeof dist);dist[1] = 0;queue<int> p;p.push(1);st[1] = true;  //st数组标记的是点是否再队列中，重复放置没有任何意义while(p.size()) {auto t = p.front();  //取出队头元素进行更新p.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]) {   //如果j变化了且队列中没有j这个点，那么就将点放进去p.push(j);st[j] = true;}}}}
}
int main() {int a, b ,c;cin >> n >> m;// 初始化链表数组头节点memset(h, -1, sizeof h);while(m--) {scanf("%d%d%d", &a, &b, &c);add(a,b,c);}spfa();if(dist[n] == 0x3f3f3f3f )    cout << "impossible" << endl;else cout << dist[n] << endl;return 0;
}

bellman_ford与spfa对于dist[n]的判断为什么不同？
因为队列里都是由起点更新到的点，不存在bellman-ford算法中未更新的点同样被边更新的情况。

注意：以上两种可适用于负权图，对于dist[n]的判定也是因为负权边的存在，所以具体看题目的范围进行判断

二、多源最短路

多源指的是能从任意一个结点出发

Floyd O(n^3)

Floyd用于处理多源汇最短路问题，即多个源点，需要直接得出点到点的最短路，时间复杂度为

步骤

初始化邻接矩阵，i == j，g[i] [j] = 0, else g[i] [j] = 0x3f3f3f3f
三重for循环 i,j,k 动态规划更新 g[j] [k] = min(g[j] [k], g[j] [i] + g[i] [k]);

练习题

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，边权可能为负数。

再给定 k 个询问，每个询问包含两个整数 x 和 y，表示查询从点 x 到点 y 的最短距离，如果路径不存在，则输出 impossible。

数据保证图中不存在负权回路。

输入格式

第一行包含三个整数 n,m,k。

接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。

接下来 k 行，每行包含两个整数 x,y，表示询问点 x 到点 y 的最短距离。

输出格式

共 k 行，每行输出一个整数，表示询问的结果，若询问两点间不存在路径，则输出 impossible。

数据范围

1≤n≤200
1≤k≤
1≤m≤20000
图中涉及边长绝对值均不超过 10000。

输入样例：
3 3 2
1 2 1
2 3 2
1 3 1
2 1
1 3
输出样例：
impossible
1

代码

#include<iostream>
#include<cstdio>
using namespace std;
//INF如果用INT_MAX(21亿)的话用加法时会溢出
const int N = 205, INF = 1e9;
int g[N][N];
int n, m, k;
void floyd() {//动态规划，三重循环后ij位置是i到j的最短路径权值for(int i = 1 ; i <= n ; i ++ ) {for(int j = 1 ; j <= n; j ++ ) {for(int k = 1 ; k <= n; k ++ ) {/*f[1][j][k]就代表了，在考虑了1节点作为中间经过的节点时，从j到k的最短路径的长度。形式化说明如下：f[k][i][j]可以从两种情况转移而来：【1】从f[k−1][i][j]转移而来，表示i到j的最短路径不经过k这个节点【2】从f[k−1][i][k]+f[k−1][k][j]转移而来，表示i到j的最短路径经过k这个节点总结就是：f[k][i][j]=min(f[k−1][i][j],f[k−1][i][k]+f[k−1][k][j])从总结上来看，发现f[k]只可能与f[k−1]有关。*/g[j][k] = min(g[j][k], g[j][i] + g[i][k]);}}}
}
int main() {cin >> n >> m >> k;int a, b, c;//多源点需要初始化每个点到自己为0，其它点为无穷大，dijkstra算法不用这样的原因是只有一个源点//直接初始化dist[1] = 0即可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--) {scanf("%d%d%d", &a, &b, &c);g[a][b] = min(g[a][b], c);}floyd();int x,y;while(k--) {scanf("%d%d", &x, &y);if(g[x][y] > INF / 2)printf("impossible\n");else printf("%d\n", g[x][y]);}return 0;
}

C++图论最短路问题总结相关推荐

数学建模学习笔记（七）——图论最短路问题
文章目录一.综述二.图论最短路问题三.几个简单的作图方法四.Dijkstra(迪杰斯特拉)算法五.Bellman-Ford算法六.总结一.综述本文主要根据图论的基本概念,介绍图论中常见 ...
Matlab 图论最短路问题模型代码
最短路问题的基本内容最短路问题研究的是,在一个点与点之间连接形成的网络图中,对应路径赋予一定的权重(可以理解为两点之间的距离),计算任意两点之间如何和走,路径最短的问题.在这里的距离可以理解成各种两 ...
一个人的旅行图论最短路问题
虽然草儿是个路痴(就是在杭电待了一年多,居然还会在校园里迷路的人,汗~),但是草儿仍然很喜欢旅行,因为在旅途中会遇见很多人(白马王子,0),很多事,还能丰富自己的阅历,还可以看美丽的风景--草儿想去 ...
Silver Cow Party 图论最短路问题
One cow from each of N farms (1 ≤ N ≤ 1000) conveniently numbered 1-N is going to attend the big cow ...
【图论】C_算竞_升降梯上（二维抽象一维）
一.题目描述开启了升降梯的动力之后,探险队员们进入了升降梯运行的那条竖直的隧道,映入眼帘的是一条直通塔顶的轨道.一辆停在轨道底部的电梯.和电梯内一杆控制电梯升降的巨大手柄. Nescafé 之塔一共 ...
【美赛学习记录】模型
美赛学习记录-2022年2月7日代码! 线性回归数据拟合插值最优化求极值插值 ARIMA 复杂网络实验模型验证 K-Fold Cross-validation k折交叉验证 [基础模型] ...
数学建模之图论——图与网络模型（一）（基本概念和最短路问题，附MATLAB源码）
图与网络的基本概念与数据结构一.图与网络的基本概念图论中图是由点和边构成的,可以反映一些对象之间的关系. 无向图无向图(简称图):没有方向,由点和边构成的图,记做G =(V , E),点是V,边 ...
图论之最短路问题题目集
注意事项 1.最短路问题的难点不在于算法,而在于建图方式 2.需要挖掘题目中隐藏的条件单.双向图,是否存在负环,是否有重边等等 3.往往不只简单图论还会和其他知识点一起出第一部分----模板一.单 ...
【BFS】【图论】极其简单的最短路问题
题目: 小C终于被小X感动了,于是决定与他看电影,然而小X距离电影院非常远,现在假设每条道路需要花费小X的时间为1,由于有数以万计的好朋友沿路祝贺,导致小X在通过某些路不得不耗费1的时间来和他们聊天, ...

C++图论最短路问题总结

最短路问题

图的存储

一、单源最短路

① 朴素Dijkstra O(n^2)

练习题

代码

② 堆优化Dijkstra O(mlogn)

练习题

代码

③ Bellman_ford O(nm)

练习题

代码

④ Spfa O(n) - O(nm)

练习题

代码

二、多源最短路

Floyd O(n^3)

练习题

代码

C++图论最短路问题总结相关推荐

最新文章

热门文章

C++图论 最短路问题总结

最短路问题

图的存储

一、单源最短路

① 朴素Dijkstra O(n^2)

练习题

代码

② 堆优化Dijkstra O(mlogn)

练习题

代码

③ Bellman_ford O(nm)

练习题

代码

④ Spfa O(n) - O(nm)

练习题

​代码

二、多源最短路

Floyd O(n^3)

练习题

代码

C++图论 最短路问题总结相关推荐

最新文章

热门文章

C++图论最短路问题总结

代码

C++图论最短路问题总结相关推荐