最短路 (超详细大全)

梦中醉卧惊起

已于 2022-07-13 20:36:43 修改

阅读量2k

点赞数 6

分类专栏：图论文章标签：图论算法数据结构

于 2022-02-18 10:37:39 首次发布

本文链接：https://blog.csdn.net/gpc_123/article/details/122998125

版权

图论专栏收录该内容

7 篇文章 0 订阅

订阅专栏

最短路

文章目录

- 最短路

最短路

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c44WrNNq-1645151598843)(C:\Users\14996\AppData\Roaming\Typora\typora-user-images\image-20211126153025611.png)]$

朴素的dijkstra使用邻接矩阵来存储
堆优化的dijkstra使用优先队列和邻接链表来存储
bellman_ford使用结构体来存储边的信息+memcpy数组,对k条边进行松弛操作
spfa是bellman_ford的优化使用队列+邻接链表
floyd使用邻接矩阵进行存储+暴力遍历

Floyd算法

该算法是一种在具有正或负边缘权重（但没有负环）的加权图中找到最短路径的算法，即支持负权值但不支持负权环。
Floyd求最短路
给定一个 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≤n^2
1≤m≤20000
图中涉及边长绝对值均不超过 10000。
输入样例：

输出样例：

impossible
1

AC思想
$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vPFCPhz8-1645151598844)(C:\Users\14996\AppData\Roaming\Typora\typora-user-images\image-20211126153121660.png)]$

AC代码

#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]);//k在最外层
}

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) 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 a, b;
        scanf("%d%d", &a, &b);
        int t = d[a][b];
        if (t > INF / 2) puts("impossible");//注意判断条件
        else printf("%d\n", t);
    }
    return 0;
}

朴素版dijkstra

给定一个 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。
输入样例：

输出样例：

AC思路
$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cpKblyVU-1645151598846)(C:\Users\14996\AppData\Roaming\Typora\typora-user-images\image-20211124175414528.png)]$

因为存在重边所以在存放数据时需要判断重复边的权值,然后取一个较小的权值;
因为是稠密图(边多点少的情况),所以直接采用邻接矩阵来存储数据;
然后时间复杂度是n^2(n是点数);
算法思路: 定义一个二维数组用来存储数据(g[N][N]);然后申请一个一维数组用来存放每一个点到达第一个点的距离;最后需要一个bool数组用来标记是否出现过;
AC代码

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 510;

int g[N][N];
int dis[N];
bool vis[N];
int n,m;

int dijkstra(){
    memset (dis,0x3f,sizeof dis);
    dis[1] = 0;
    for(int i = 0;i < n;++ i){
        int t = -1;
        for(int j = 1;j <= n;++ j){//从1号点开始
            if(!vis[j]&&(t==-1||dis[t]>dis[j])){
                t = j;
            }
        }
        vis[t] = true;
        for(int i = 1;i <= n;++ i){
            dis[i] = min (dis[i],dis[t] + g[t][i]);
        }
    }
    if(dis[n] == 0x3f3f3f3f) return -1;
    return dis[n];
}

int main(){
    cin>>n>>m;
    memset (g,0x3f,sizeof g);
    int x,y,z;
    for(int i = 1;i <= m;++ i){
        cin >> x >> y >> z;
        g[x][y] = min(g[x][y],z);
    }
    cout << dijkstra() << endl;
    return 0;
}

堆优化版的dijkstra

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为非负值。
请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1。
输入格式
第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。
如果路径不存在，则输出 −1。
数据范围
1≤n,m≤1.5×105,
图中涉及边长均不小于 00，且不超过 10000。
输入样例：

输出样例：

AC思想
因为n和m的范围是1~1.5*10^5,大于105,所以朴素版的dijksta n^2的复杂度不能够满足,所以这种边和点成正比的关系需要用邻接表+优先队列进行优化处理
pair排序,优先对first进行排序,如果first相同则对second进行排序,通过对距离进行排序后,在前面的距离对应的点就是我们需要进行操作的点和距离
mlogn
AC代码

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;
typedef pair<int ,int >PII;
#define IOS std::ios::sync_with_stdio(false);std::cin.tie(0);
const int N = 1e6 + 10;
int n,m;
int h[N],e[N],ne[N],w[N],idx;
int dis[N];
bool vis[N];

void add(int a,int b,int c){
    w[idx] = c;e[idx] = b;ne[idx] = h[a];h[a] = idx ++;
}

int dijkstra(){
    memset(dis, 0x3f, sizeof dis);
    dis[1] = 0;
    priority_queue<PII,vector<PII>,greater<PII> >heap;
    heap.push({0,1});//0是距离,1是结点号数
    while(heap.size()){
        auto t = heap.top();
        heap.pop();

        int distance = t.first,ver = t.second;
        if(vis[ver]) continue;
        vis[ver] = true;

        for(int i = h[ver]; i!=-1; i = ne[i]){
            int j = e[i];
            if(dis[j]>dis[ver] + w[i]){
                dis[j] = dis[ver] + w[i];
                heap.push({dis[j],j});
            }
        }
    }
    if(dis[n] == 0x3f3f3f3f) return -1;
    return dis[n];
}

int main(){
    
    cin >> n >>m;
    memset(h,-1,sizeof h);

    while(m --){
        int a,b,c;
        cin >> a >> b >> c;
        add(a, b, c);
    }

    cout << dijkstra() <<endl;
    return 0;
}

第二标尺:有多条路径相同时
在有两条路径相同时,需要再增加一条判断准则(第一准则是距离)
1.给每一条边加一个边权(花费),要求在最短路径有多条时要求路径上花费最小或最大
2.给没个点加一个点权,和边权一样问法
3.直接问有多少条最短路径
解题方法:
是增加一个数组存放新的边权或点权或做短路径条数,然后在算法中修改优化d[v]步骤
1.cost[u][v]表示u->v的花费,并增加一个数组c[],令从起点s到达顶点u的最少花费为c[u],初始时只有c[s]=0,其余都为INF

for (int v = 0; v < n;v++){//以u为中介开始优化到s的距离
    if(vis[v]==false&&G[u][v]!=INF){
        if(d[u]+G[u][v]<d[v]){
        dis[v] = dis[u] + G[u][v];//dis[v]为顶点v到顶点s的最短距离
        c[v]=c[u]+cost[u][v];
        }
    else if(d[u]+G[u][v]==d[v]&&c[u]+cost[u][v]<c[v]){//最短距离相同时看能否使c[v]更优
        c[v]=cost[u][v]+c[u];
        }
    }
}

2.weight[u]表示城市u的点权(题目输入),并增加一个数组w[],s到u的最大物资为w[u],初始化时只有w[s]为weight[s],其余w[u]均为0

for (int v = 0; v < n;v++){//以u为中介开始优化到s的距离
    if(vis[v]==false&&G[u][v]!=INF){
      if(d[u]+G[u][v]<d[v]){
        dis[v] = dis[u] + G[u][v];//dis[v]为顶点v到顶点s的最短距离
        w[v]=w[u]+weight[v];
        }
    else if(d[u]+G[u][v]==d[v]&&w[u]+weight[v]>w[v]){
        w[v]=w[u]+weight[v];
        }
    }
}

3.增加数组num[],s到u的最短路径条数为num[u],num[s]=1,其余num[u]=0;

for (int v = 0; v < n;v++){//以u为中介开始优化到s的距离
     if(vis[v]==false&&G[u][v]!=INF){
      if(d[u]+G[u][v]<d[v]){
        dis[v] = dis[u] + G[u][v];
        num[v]=num[u];//如果可以更新,则传承下去,直到遇到多条最短路径
        }
    else if(d[u]+G[u][v]==d[v]){
        num[v]+=num[u];//最短距离相同时,累加次数
        }
    }
}

典例

#include<bits/stdc++.h>
using namespace std;
const int inf=999999;
int weight[1010],e[1010][1010],dis[1010],rode[1010],w[1010];
bool visit[1010];
int main()
{
    fill(e[0],e[0]+1010*1010,inf);
    fill(dis,dis+1010,inf);
    int n,m,c1,c2;
    int a,b,c;
    cin>>n>>m>>c1>>c2;
    for(int i=0;i<n;i++){
        cin>>weight[i];
    }
    for(int i=0;i<m;i++){
        cin>>a>>b>>c;
        e[a][b]=e[b][a]=c;
    }
    dis[c1]=0;
    rode[c1]=1;
    w[c1]=weight[c1];
    for(int i=0;i<n;i++){
        int minn=inf,u=-1;
        for(int j=0;j<n;j++){
            if(visit[j]==false&&dis[j]<minn){
                minn=dis[j];
                u=j;
            }
        }
        if(u==-1) break;
        visit[u]=true;
        for(int v=0;v<n;v++){
            if(dis[v]>dis[u]+e[u][v]&&visit[v]==false){
                dis[v]=dis[u]+e[u][v];
                rode[v]=rode[u];//路径数
                w[v]=w[u]+weight[v];//点的权重
            }
            else if(dis[v]==dis[u]+e[u][v]&&visit[v]==false){
                rode[v]+=rode[u];
                if(w[v]<w[u]+weight[v]){
                    w[v]=w[u]+weight[v];
                }
            }
        }
    }
    cout<<rode[c2]<<" "<<w[c2];
 
}

dijkstra+DFS:
在dijkstra中记录所有最短路径(只考虑距离),然后在这些最短路径中选出一条第二标尺最优的路径
1.使用dijkstra算法记录所有最短路径
要记录所有最短路径,因此每个节点都有多个前驱结点,则原来的pre数组只能记录一个前驱结点的方法就不在适用,可以设置vector<int>pre[maxn],这样对于每一个结点,pre[v]就是一个边长数组vector,用来存放结点v的前驱结点
对于需要查询某个顶点u是否在顶点v的前驱中的题目,也可以把pre数组设置为set数组,此时可以使用pre[v].count(u)来查询
$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XlYUG0ww-1645151598847)(C:\Users\14996\AppData\Roaming\Typora\typora-user-images\image-20210804195235354.png)]$

vector<int>pre[MAXV];
void dijkstra(int s){
    fill(d, d + MAXV, INF);
    d[s] = 0;
    for (int i = 0; i < n;i++){
        int u = -1, MIN = INF;
        for (int j = 0; j < n;j++){
            if(vis[j]==false&&d[j]<MIN){
                u = j;
                MIN = d[j];
            }
        }
        if(u==-1)  return;
        vis[u] = true;
        for (int v = 0; v < n;v++){
            if(vis[v]==false&&G[u][v]!=INF){
                if(d[u]+G[u][v]<d[v]){
                    d[v] = d[u] + G[u][v];
                    pre[v].clear();
                    pre[v].push_back(u);//令v的前驱为u
                }else if(d[u]+G[u][v]==d[v]){
                    pre[v].push_back(u);
                }
            }
        }
    }
}

2.DFS遍历所有最短路径,找出一条第二标尺最优的路径
$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wORgYX2h-1645151598847)(C:\Users\14996\AppData\Roaming\Typora\typora-user-images\image-20210804201127740.png)] [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tglA9Vhj-1645151598848)(C:\Users\14996\AppData\Roaming\Typora\typora-user-images\image-20210804201614515.png)]$

int optvalue;//第二标尺最优值optValue
vector<int> pre[MAXV];//存放结点的前驱结点
vector<int> path, temppath;//最优路径,临时路径
void DFS(int v){//v为当前访问结点
    if(v==st){//递归边界,达到叶子节点,即路径的起点
        temppath.push_back(v);//将起点st加入到临时路径最后面
        int value;//存放临时路径的第二标尺的值
        计算路径temppath的value值;
        if(value优于optvalue){
            optvalue = value;
            path = temppath;//更新最优路径
        }
        temppath.pop_back();//删除刚加入的结点
        return;
    }
    //递归式
    temppath.push_back(v);//当前访问结点加入到临时路径最后面
    for (int i = 0; i < pre[v].size();i++){
        DFS(pre[v][i]);
    }
    temppath.pop_back();//遍历完所有前驱结点,将当前结点v删除
}

//边权之和
//三条边两个边权注意i的范围
int value=0;
for(int i=temppath.size()-1;i>0;i--){//倒序访问
    int id=temppath[i],idnext=temppath[i-1];
    value+=v[id][idnext];
}
//点权之和
//注意i的范围
int value=0;
for(int i=temppath.size()-1;i>=0;i--){
    int id=temppath[i];
    value+=w[id]
}

旅行地图给出了公路沿线城市之间的距离，以及每条公路的成本。现在，您应该编写一个程序来帮助旅行者确定从出发城市到目的地之间的最短路径。如果这样的最短路径不是唯一的，则应该输出成本最低的路径，该路径保证是唯一的。
打印第二标尺的最短路径

#include <algorithm>
#include <cstdio>
using namespace std;

const int maxv = 510, INF = 0x7fffffff;
int G[maxv][maxv]; //各边距离 
int d[maxv]; //源点到各顶点的最短路径
int w[maxv][maxv]; //各边花费
int cost[maxv]; //源点到各顶点的最小花费 
bool vis[maxv] = {false};
int pre[maxv];
int n, m, st, des;  

void Dijkstra(){
	fill(d, d + maxv, INF);
	fill(cost, cost + maxv, INF);
	for(int i = 0; i < n; i++)
		pre[i] = i;
	d[st] = 0;
	cost[st] = 0;
	for(int i = 0; i < n; i++){
		int u = -1, min = INF; 
		for(int j = 0; j < n; j++){ //找到最小d[u] 
			if(vis[j] == false && d[j] < min){
				min = d[j];
				u = j;
			}
		} 
		if(u == -1) return; //不连通 
		vis[u] = true;
		for(int v = 0; v < n; v++){
			if(G[u][v] != INF && vis[v] == false){
				if(d[u] + G[u][v] < d[v]){
					d[v] = d[u] + G[u][v];
					cost[v] = cost[u] + w[u][v];
					pre[v] = u;
				}
				else if(d[u] + G[u][v] == d[v]
				&& cost[u] + w[u][v] < cost[v]){
					cost[v] = cost[u] + w[u][v];
					pre[v] = u;
				}
			}
		}
	}
}

void DFS(int v){ 
	if(v == st){ //到达起点 
		printf("%d", st);
		return;
	}
	DFS(pre[v]);
	printf(" %d", v);
}

int main(){
	scanf("%d%d%d%d", &n, &m, &st, &des);
	fill(G[0], G[0] + maxv * maxv, INF);
	int u, v;
	for(int i = 0; i < m; i++){
		scanf("%d%d", &u, &v);
		scanf("%d%d", &G[u][v], &w[u][v]);
		G[v][u] = G[u][v];
		w[v][u] = w[u][v];
	}
	Dijkstra();
	DFS(des);
	printf(" %d %d", d[des], cost[des]);
	return 0;
}

有边数限制的最短路(bellman-ford)

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你求出从 1 号点到 n 号点的最多经过 k 条边的最短距离，如果无法从 1 号点走到 n 号点，输出 impossible。
注意：图中可能 存在负权回路 。
输入格式
第一行包含三个整数 n,m,k。
接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
输出格式
输出一个整数，表示从 1 号点到 n 号点的最多经过 k 条边的最短距离。
如果不存在满足条件的路径，则输出 impossible。
数据范围
1≤n,k≤500,
1≤m≤10000,
任意边长的绝对值不超过 10000。
输入样例：

输出样例：

AC思路
$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rtH8W8Pn-1645151598849)(C:\Users\14996\AppData\Roaming\Typora\typora-user-images\image-20211124202637461.png)]$

因为边权有负数,所以不能使用dijksta算法,因为有边数限制所以只能使用bellman-ford算法,因为存在负权回路,但是有边数的限制,所以不会造成死循环,但是最后dis[n]可能不会等于0x3f3f3f3f;注意最后的判断条件;
o(mn)的时间复杂度
算法思路:就是遍历k次,每一次都要遍历所有边,并用选取出来的到结点1的最短距离进行更新,然后找到最短距离;;;(暴力) 所以直接用结构体进行边的存储
AC代码

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;
const int N = 510, M = 10010;
struct Edge
{
    int a, b, c;
}edges[M];

int n, m, k;
int dist[N];
int last[N];

void bellman_ford()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;//第一个点的距离为0
    for (int i = 0; i < k; i ++ )//限制的k条边,就是从中选择k次
    {
        memcpy(last, dist, sizeof dist);//备份一下,每次在前一次的基础上更新
        for (int j = 0; j < m; j ++ )//每一次选边都要遍历m条边(也就是所有的边)
        {
            auto e = edges[j];//等于第j条边
            dist[e.b] = min(dist[e.b], last[e.a] + e.c);//e.a是存放的是连接这个点的上一个点
        }
    }
}

int main()
{
    scanf("%d%d%d", &n, &m, &k);

    for (int i = 0; i < m; i ++ )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        edges[i] = {a, b, c};
    }

    bellman_ford();

    if (dist[n] > 0x3f3f3f3f / 2) puts("impossible");//小心有负权回路
    else printf("%d\n", dist[n]);

    return 0;
}

spfa求最短路

SPFA:判定负权回路,处理负权边的最短路问题
bfs思想判断负环:如果不存在负权边,则不需要num数组
spfa+队列优化+链式前向星+打印最短路径

#include <iostream>
#include <string>
#include <queue>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int Maxn = 5e5 + 10;
const int INF = 1e9;
struct Node{
    int to, w, Next;
}e[Maxn];
int n, k;
ll dis[Maxn],path[Maxn];
ll head[Maxn], cnt;
ll num[Maxn];
void init(){
    cnt = 0;
    memset(head, -1, sizeof(head));
    memset(num,0 sizeof(num));
    memset(path, -1, sizeof(path));
}
void addEdge(int u, int v, int w){
     e[cnt].to = v;
     e[cnt].w = w;
     e[cnt].Next = head[u];
     head[u] = cnt++;
}
void Spfa(){
    priority_queue<P, vector<P>, greater<P> > que;
    for (int i = 1; i <= k; i++) dis[i] = INF;
    que.push(make_pair(0, 1));
    dis[1] = 0;
    while (!que.empty()){
        P now = que.top();
        que.pop();
        int s = now.second;
        for (int i = head[s]; i != -1; i = e[i].Next){
            int v = e[i].to;
            int w = e[i].w;
            if (dis[v] > dis[s] + w){
                dis[v] = dis[s] + w;
                path[v] = s;
                que.push(make_pair(dis[v], v));
            }
        }
    }
}
vector<int> ve;
int getAns (int k){
    int ans = 0;
    for ( ; k != -1; k = path[k]) {
        ve.push_back(k);
    }
    reverse(ve.begin(), ve.end());
    return ve.size();
}
int main (){
    cin >> n >> k;
    init();
    int u, v;
    for (int i = 0; i < n; i++){
        cin >> u >> v;
        addEdge(u, v, 1);
    }
    Spfa();
    int ans = getAns(k);
    if (dis[k] == INF) cout << -1 << endl ;
    else{
        cout << ans << endl;
        for (int i = 0; i < ans; i++) cout << ve[i] << endl ;
    }
    return 0;
}

spfa判断负环

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你判断图中是否存在负权回路。
输入格式
第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
输出格式
如果图中存在负权回路，则输出 Yes，否则输出 No。
数据范围
1≤n≤2000,
1≤m≤10000
图中涉及边长绝对值均不超过 10000。
输入样例：

输出样例：

Yes

AC思想
根据抽屉原理,如果边数比点数多,则存在负环
然后需要判断每一个出发是否存在负环
AC代码

#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>

using namespace std;
const int N = 2010, M = 10010;
int n, m;
int h[N], w[M], e[M], ne[M], idx;
int dist[N], cnt[N];
bool vis[N];

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

bool spfa(){
    queue<int> q;
// 这里不需要初始化dist数组为 正无穷。不用初始化的原因是， 如果存在负环， 那么dist不管初始化为多少， 都会被更新
    for (int i = 1; i <= n; i ++ ){
        vis[i] = true;
        q.push(i);
    }

    while (q.size()){
        int t = q.front();
        q.pop();
        vis[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];
                cnt[j] = cnt[t] + 1;

                if (cnt[j] >= n) return true;//抽屉原理,一定有回路
                if (!vis[j]){
                    q.push(j);
                    vis[j] = true;
                }
            }
        }
    }

    return false;
}

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);
    }

    if (spfa()) puts("Yes");
    else puts("No");

    return 0;
}

梦中醉卧惊起

关注

6
点赞
踩
23

收藏

觉得还不错? 一键收藏
2
评论
最短路 (超详细大全)

最短路最短路朴素的dijkstra使用邻接矩阵来存储堆优化的dijkstra使用优先队列和邻接链表来存储bellman_ford使用结构体来存储边的信息+memcpy数组,对k条边进行松弛操作spfa是bellman_ford的优化使用队列+邻接链表floyd使用邻接矩阵进行存储+暴力遍历Floyd算法该算法是一种在具有正或负边缘权重（但没有负环）的加权图中找到最短路径的算法，即支持负权值但不支持负权环。Floyd求最短路给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，
复制链接

扫一扫