最短路问题 - Dijkstra，Bellman_ford，SPFA与SPFA判断负环，Floyd

最新推荐文章于 2022-12-09 11:47:22 发布
最新推荐文章于 2022-12-09 11:47:22 发布
阅读量675 收藏
点赞数
分类专栏： 算法 文章标签： c++ 算法 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52169223/article/details/121316282
版权

Dijkstra

朴素Dijkstra
图中可能存在重边和自环，所有边权均为非负值

#include<bits/stdc++.h>

//朴素版Dijkstra适合稀疏图
//稠密图：邻接矩阵

using namespace std;

const int N=510;
int n,m;
int g[N][N];
int dist[N];
bool st[N];//初始为 false 

int dijkstra()
{
	memset(dist,0x3f3f3f3f,sizeof dist);
	dist[1]=0;
	for(int i=1;i<=n;i++)
	{
		int t=-1;
		for(int j=1;j<=n;j++)
			if(!st[j]&&(t==-1||dist[t]>dist[j])) t=j;//确定中间节点 
			
		st[t]=true;
		
		for(int j=1;j<=n;j++)
			dist[j]=min(dist[j],dist[t]+g[t][j]);
	}
	if(dist[n]==0x3f3f3f3f) return -1;
	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);
	}
	int t=dijkstra();
	printf("%d",t);
	return 0;
}

堆优化版Dijkstra
图中可能存在重边和自环，所有边权均为非负值

#include<bits/stdc++.h>

//堆优化Dijkstra适合稀疏图
//稀疏图：邻接表 
 
using namespace std;
typedef pair<int,int> PII;
const int N=1000010;

int n,m;
//邻接表 
int h[N],w[N],e[N],ne[N],idx;
//vector<vector<PII>> gra;  邻接矩阵


int dist[N];
bool st[N];//初始为 false 

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,0x3f3f3f3f,sizeof dist);
	dist[1]=0;
	
	priority_queue<PII,vector<PII>,greater<PII>> heap;//小根堆 
	heap.push({0,1});
	//first :距离
	//second:点的位置
	
	while(heap.size())
	{
		auto 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];//此时的 j 为 ver 的下一个点 
			if(dist[j]>w[i]+distance)
			{
				dist[j]=w[i]+distance;
				heap.push({dist[j],j});
			}
		}
	}
	if(dist[n]==0x3f3f3f3f) return -1;
	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);
	}
	int t=dijkstra();
	printf("%d",t);
	return 0;
}

#include<bits/stdc++.h>

using namespace std;
const int N=100010,M=2*N;
int n;
int h[N],e[M],ne[M],idx;


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

int main()
{
    memset(h,-1,sizeof h);
    cin>>n;
    for(int i=1;i<=n-1;i++)
    {
        int a,b;cin>>a>>b;
        add(a,b);
        //add(b,a);
    }
    
    for(int u=1;u<=n;u++)
    {
        cout<<u<<endl;
        for(int i=h[u];i!=-1;i=ne[i])
	    {
	    	int j=e[i];
	    	cout<<i<<" "<<j<<" "<<endl;
 	    }
 	    cout<<endl;
    }
    
    return 0;
}
/*
数据：
9
1 2
1 7
1 4
2 8
2 5
4 3
3 9
4 6

*/

在这里插入图片描述

Bellman_ford
有边数限制的的最短路
图中可能存在重边和自环， 边权可能为负数

#include<bits/stdc++.h>

using namespace std;
const int N=510,M=10010;

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

struct Edge
{
    int a,b,w;
}edges[M];

int bellman_ford()
{
    memset(dist,0x3f3f3f3f,sizeof dist);
    dist[1]=0;
    
    for(int i=1;i<=k;i++)
    {
        memcpy(backup,dist,sizeof dist);
        for(int j=1;j<=m;j++)
        {
            int a=edges[j].a,b=edges[j].b,w=edges[j].w;
            dist[b]=min(dist[b],backup[a]+w);
        }
    }
    if(dist[n]>0x3f3f3f3f/2) return -1e8;
    //返回一个不可能出现的值，特判一下
    return dist[n];
}

int main()
{
    scanf("%d%d%d",&n,&m,&k);
    
    for(int i=1;i<=m;i++)
    {
        int a,b,w;
        scanf("%d%d%d",&a,&b,&w);
        edges[i]={a,b,w};
    }
    if(bellman_ford()==-1e8) puts("impossible");
    else printf("%d",bellman_ford());
    return 0;
}

SPFA
SPFA是在Bellman_ford上做的一点优化

（对于有些题spfa可能会被卡掉，谨慎使用，如有需要请自行百度）
Bellman_ford算法可以存在负权回路，
因为其存在循环次数限制，最终也不会进入死循环；
但是SPFA算法不可以，
由于用了队列来存储，只要发生了更新就会不断的入队，从而进入死循环，
因此存在负权回路，不要使用SPFA。

图中可能存在重边和自环， 边权可能为负数
使用spfa时，需要保证不存在负环
负环是路径之和是负数的环，不是指包含负权边的环。

#include<bits/stdc++.h>

using namespace std;
const int N=100010;
int h[N],e[N],ne[N],w[N],idx;
int dist[N];
bool st[N];
int n,m;

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

int 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();
        //将t弹出来了，重置t为false
        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])
                {
                    q.push(j);
                    st[j]=true;
                }
            }
        }
    }
    //为什么在Bellman_ford中特判的是 dist[n]>0x3f3f3f3f/2
    //而在spfa中特判的是 dist[n]==0x3f3f3f3f;
    /*
	  最主要的原因就是，
	  Bellman_ford中对于每一个点都进行的遍历，
	  spfa只遍历了需要的点
	*/
    if(dist[n]==0x3f3f3f3f) return -1e9;
    return dist[n];
}

int main()
{
    memset(h,-1,sizeof h);
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        int a,b,c;cin>>a>>b>>c;
        add(a,b,c);
    }
    if(spfa()==-1e9) cout<<"impossible";
    else cout<<spfa();
    return 0;
}

SPFA判断负环

//负环是路径之和是负数的环，不是指包含负权边的环。
#include<bits/stdc++.h>

using namespace std;
const int N=10010;
int n,m;
int h[N],e[N],ne[N],w[N],idx;
int dist[N],cnt[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++;
}

bool spfa()
{
	//只要负环存在必定存在某些点的距离最终被更新为负无穷，因此我们不需要对距离进行初始化
    queue<int> q;
    for(int i=1;i<=n;i++)
    {
        st[i]=true;
        q.push(i);
    }
    
    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];
                cnt[j]=cnt[t]+1;
                if(cnt[j]>=n) return true;
                if(!st[j])
                {
                    q.push(j);
                    st[j]=true;
                }
            }
        }
        
    }
    return false;
}

int main()
{
    cin>>n>>m;
    memset(h,-1,sizeof h);
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
    }
    if(spfa()) cout<<"Yes";
    else cout<<"No";
    return 0;
}

Floyd
基于动态规划的思想，求多源最短路
可以存在负权边，不能存在负权回路

#include<bits/stdc++.h>

using namespace std;
const int N=210,INF=1e9;
int d[N][N];//邻接矩阵
int n,m,Q;

void floyd()//n^3  8000000次 时间复杂度高
{
    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()
{
    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]=INF;
    while(m--)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        d[a][b]=min(d[a][b],c);//初始化并更新从a到b的最短距离
    }
    floyd();
    while(Q--)
    {
        int a,b;scanf("%d%d",&a,&b);
        if(d[a][b]>INF/2) puts("impossible");
        //d[a][b] 为什么>INF/2,见下方代码与图
        else printf("%d\n",d[a][b]);
    }
    return 0;
}

错误代码：

#include<bits/stdc++.h>

using namespace std;
const int N=210,INF=1e9;
int d[N][N];
int n,m,k;

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()
{
    scanf("%d%d%d",&n,&m,&k);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            if(i!=j) 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(k--)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        if(d[x][y]==INF) puts("impossible");
        //
        else printf("%d\n",d[x][y]);
    }
    
    return 0;
}

在这里插入图片描述

//1~4 存在   4~1 不存在
输入
5 10 10
1 5 10
3 4 9
3 2 10
3 3 7
3 1 5
4 5 7
1 2 -5
5 1 6
4 3 8
5 5 6
4 1
1 4
5 2
3 2
5 4
4 5
2 2
3 5
3 1
1 1

输出
13
999999995
1
0
impossible
7
0
15
5
0

标准答案
13
impossible
1
0
impossible
7
0
15
5
0
Axing0022
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
判断图有无环_算法之判断一个图是否有环
weixin_30082367的博客
01-17 1320
在一些经典算法中，经常需要判断一些图是否具有环路，比如拓扑排序，需要在最初判断该图是否有环路，如有有环路，则无法找到最长的一条线，比如dijkstra算法，每找到一条最短的边，都要判断找到的边和现有的树是否已经构成了环路。因此，在这篇博客，我们重点来说一个判断图是否有环的算法。首先我们介绍一个对于无向图和有向图通用的算法，先讲算法思路：1.统计各个图中各个点的入度数(能够到达这个点的点的数量)。2...
spfa判负环
magnte的博客
08-12 207
由于进入负权环会一直循环，所以spfa判断负环只需加一个cnt数组记录它连的边数，对于每个点，只要他的边数大于等于n即说明图中存在负环。 由于负环不一定存在在由1出发的点的集合，所以一开始入队需要将所有点入队。 还有一点在判断负环中可以不需要初始化d数组 原因：有负环的话相当于某些点到起点的距离为负无穷，然后SPFA算法是正确的，且初始时这些点的距离为0,0大于负无穷，所以一定会把这些距离为负无穷的点不断更新。 模板题： 给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可.
Dijkstra 和 Bellman-Ford算法以及spfa判断负环路
qq_43842119的博客
06-02 727
在说bellman_ford算法前，先解释dijkstra算法的思想 我们用 dis[ ] 数组来存放 i 点到起点的最短距离 1、首先它是从起点开始，广度遍历，逐层更新，靠近起点的先被确定最终距离 2、如果我们要更新 dis[y] 的最短距离，则一定用比它距离要短的 dis[x] 来更新 如果dis[y]为全局最短，则dis[y] 不会再被更新，因为没有更短的 dis[x]值可以来...
Weekly7作业——Floyd/Dijkstra/带负环的SPFA
明天我能有猫吗的博客
04-17 183
A - TT 的魔法猫 题目 众所周知，TT 有一只魔法猫。 这一天，TT 正在专心致志地玩《猫和老鼠》游戏，然而比赛还没开始，聪明的魔法猫便告诉了 TT 比赛的最终结果。TT 非常诧异，不仅诧异于他的小猫咪居然会说话，更诧异于这可爱的小不点为何有如此魔力？ 魔法猫告诉 TT，它其实拥有一张游戏胜负表，上面有 N 个人以及 M 个胜负关系，每个胜负关系为 A B，表示 A 能胜过 B，且胜负关系具...
第十八章 SPFA算法以及负环问题（利用dijkstra推导出该算法，超级详细！！）
Turing_Sheep的博客
12-09 1619
通过图解以及特殊的思路帮助你理解SPFA以及相关的负环问题。
蓝桥杯 最短路问题 dijkstra算法负权值计算
highlighters的博客
07-24 1023
原题如下： 试题 算法训练 最短路 资源限制 时间限制：1.0s 内存限制：256.0MB 问题描述 给定一个n个顶点，m条边的有向图（其中某些边权可能为负，但保证没有负环）。请你计算从1号点到其他点的最短路（顶点从1到n编号）。 输入格式 第一行两个整数n, m。 接下来的m行，每行有三个整数u, v, l，表示u到v有一条长度为l的边。 输出格式 共n-1行，第i行表示1号点到i+1号点的最短路。 样例输入 3 3 1 2 -1 2 3 -1 3 1 2 样例输出 -1 -2 数据规模与约定 对于1
Shortest-path-template.rar_SPFA
09-23
本压缩包文件“Shortest-path-template.rar_SPFA”提供了四种经典的最短路径算法模板：Dijkstra算法、Bellman-Ford算法、SPFA（Shortest Path Faster Algorithm）以及Floyd-Warshall算法。这些算法主要适用于加权有...
最短路全家桶（Floyd,Dijkstra,SPFA）
06-02
相比于Bellman-Ford算法，SPFA在实践中通常更快，但其最坏情况下的时间复杂度仍为O(n^2)。SPFA对于稀疏图，即边的数量远小于节点数量的情况，表现良好。 链式前向星存图是一种常用的图存储结构，它使用邻接表而非...
图论基础就是一些NOI学习中比较简单的图论基础，如存图，读图，dijkstra，SPFA，Bellman-Ford，Floyd等
最新发布
07-06
图论基础就是一些NOI学习中比较简单的图论基础，如存图，读图，dijkstra，SPFA，Bellman-Ford，Floyd等
三种算法（Floyd、Dijkstra、SPFA）求单源点最短路径。
04-13
与Dijkstra算法不同，SPFA使用队列来处理节点，但允许在队列中有多个相同节点，以防止负权环导致无限循环。尽管SPFA在理论上可能出现最坏情况下的O(V^2)时间复杂度，但在实际应用中通常表现出较好的性能。 在Main....
Dijkstra无法处理负权边的原因
Stillboring的博客
05-31 4734
为啥不能处理负权? 首先我们要清楚一个点:Dijkstra是每次贪心的选择跟当前邻接的点,而不会去考虑处邻接之外的其他点 而如果所有Dijkstra算法适用于不存在负权边的图(有无向均可),这个是因为迪杰斯特拉算法是基于贪心策略，每次都找一个距源点最近的点，然后将该距离定为这个点到源点的最短路径；但如果存在负权边，那么直接得到的最短路不一定是最短路径，因为可能先通过并不是距源点最近的一个次优点，再通过一个负权边，使得路径之和更小，这样就出现了错误。如下： 1——>2权值为5，1——>..
dijkstra算法，真的不能计算负权值吗？
highlighters的博客
07-26 7474
很多人都知道dijkstra算法不能计算负权值。 但是不是所有人都深刻地认识了这一原因。 以下面的例子为例： 如果用dijkstra算法来计算最短路径，一定会出错。 因为按照dijkstra算法，它的原则是基于贪心进行查找，所以它的查找顺序应该是：BEDC。 造成的结果就是：找到第二个节点时，就会直接判断E的最短路径为-3.并且后续节点的查找也不会改变这个值。 但是显然，我们知道E的最短路径为-4. 出现这种情况的根本原因是，负环（含负值的环）出现。导致贪心的查找逻辑无法继续成立。 用通俗的话来说，就是面
对于dijkstra与floyd在有向图和无向图的判断环方法
weixin_46274692的博客
10-24 1431
说明：dijkstra是基于点的算法，floyd是基于边的算法，因此在求最小环的时候，floyd可以轻松的修改点的初始化，从而对求环有很大帮助。 Dijkstra在无向图中求最小环 说明：对于dijkstra而言，是否有向判断方法几乎一致 思想：在迭代过程中，假设求出了i->j的最短路径，这是我们擦除这条边a，然后再次求i->j的最短路径b，此时如果b路径存在，那么a+b就是最小环的长度 Floyd求无向图的最小环 思想：对于有标号的节点，我们从小到大进行中间点（第一层循环）k的遍历，那么每次k
“多次入堆的” Dijkstra在有负边没负环的时候能用吗？
white514的博客
01-14 1015
Dijkstra 在有负边但没负环时正确吗？ 让我们小小地检验一下吧！
三种路径算法：Dijstra、Bellman-Ford、Floyd-Warshall
u013914309的博客
05-16 372
#.Dijstra算法： 求单源最短路径，不允许出现负边。n-1次外循环。 流程： 1.将所有节点分为：原点集合S、剩余节点集合D，将源节点装入S，用dist记录各个节点的距离。 2.每轮循环都从D中找出当前距离最小的点a，移入S，同时更新D中与a相邻的节点的最小距离: dist[p] = Math.min(dist[p], dist[a] + E(a,p) ); n-1轮循环后，得到的dist记录...
最短路算法
我是传奇
09-19 189
最短路径问题旨在寻找图中两节点之间的最短路径，常用的算法有以下四种。注意是把图处理成无向还是有向Dijkstra's (权值非负) 1 Dijkstra's算法解决的是图中单个源点到其它顶点的最短路径。只能解决权值非负 2 Dijkstral只能求出任意点到达源点的最短距离（不能求出任意两点之间的最短距离），同时适用于有向图和无向图，复杂度为O(n^2). 3算法的过程： 1设置顶点集合...
图算法总结（判断有环、最短路径）
向着星辰大海
02-22 4189
有向图判断有环 拓扑排序 if __name__ == "__main__": v = [[0, 0, 0, 0, 1], [1, 0, 0, 0, 0], [0, 0, 0, 1, 1], [0, 0, 0, 0, 0], [0, 1, 0, 0, 0]] e = [[]] in_v = {} cnt = 0 visited = set() ...
【正环判断】POJ-1860 Currency Exchange（Dijkstra）
m0_59701064的博客
04-22 356
上链接：1860 -- Currency Exchange 大部分题解都是Bellmean_Ford和SPFA，最近在练Dijkstra的板，就放在这道题上写一写叭。 题意 给定n种货币，且存在m种交易方式，对于每一种交易方式，有税率与佣金等参数。例如现存在一种交易方式:从货币A到货币B，原有货币A的数量为Sa,税率为rate,佣金为dec，则可得货币B的数量为Sb=(Sa-dec)*rate。问经过交易能否使原有货币价格升高。 分析 由于允许的货币交易次数是无限的，故不能将视野局限于某几次交易能
SPFA 算法和Bellman-Ford 算法与Dijkstra 算法、Floyd 算法有什么异同以及创新性改进或应用
06-03
SPFA算法和Bellman-Ford算法与Dijkstra算法、Floyd算法有以下异同和创新性改进或应用： 异同点： 1. Dijkstra算法、Floyd算法和Bellman-Ford算法均不能处理负权边，而SPFA算法可以。 2. Dijkstra算法适用于处理正权边的最短路径问题，时间复杂度较低，但只适用于无负权边的情况，需要处理负权边则需要使用其他算法，如Bellman-Ford算法和SPFA算法； 3. Floyd算法适用于求解含有负权边和负环的图的最短路径，时间复杂度较高，但适用于任何情况。 4. Bellman-Ford算法适用于处理带负权边的最短路径问题，并且可以检测到图中是否存在负环。 5. SPFA算法是Bellman-Ford算法的一种优化，具有更快的速度和更好的效率。 创新性改进或应用： 1. Dijkstra算法的改进：A*算法，利用启发式搜索函数减少搜索的节点数，提高效率。 2. Floyd算法的改进：Johnson算法，利用重新赋值节点权值的方式把负权边转化成正权边，然后用Dijkstra算法来求解最短路径。 3. Bellman-Ford算法的改进：SPFA算法，通过队列优化，减少了算法的时间复杂度。 4. SPFA算法的改进：SLF算法和LLL算法，对队列的优化方式不同，使得算法更加高效。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值