[最短路SPFA]--启动！！！！！

已于 2024-08-03 19:18:05 修改
阅读量465 收藏 9
点赞数 8
文章标签： c++ 图论 算法
于 2024-07-31 15:14:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zz20090411/article/details/140823728
版权

基础模板

#include<bits/stdc++.h>
#define ll long long
#define fi first
#define se second
#define pb push_back
#define PII pair<int,int >
#define IOS ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
using namespace std;
const int N = 1e6+10;
int n,m,s;
//int cnt[N];
bool vis[N];
int dis[N];
vector<PII> v[N];
//bool suc = 0;
void spfa(int s)
{
	queue<int> q;
	for(int i=1;i<=n;i++)
	{
		//v[i].clear();//1.测试多组数据，并且每组数据重新建边时加上
		dis[i] = 1e9;
		//vis[i] = 0;
		//cnt[i] = 0;//在1.的情况下，还要查询负环时加上
	}
	vis[s] = 1;
	dis[s] = 0;
	q.push(s);
	while(q.size())
	{
		int now = q.front();
		q.pop();
		vis[now] = 0;
		for(auto t:v[now])
		{
			int spot = t.fi,w = t.se;
			if(dis[spot]>dis[now]+w)
			{
				//cnt[spot] = cnt[now]+1;//查询负环时加上
				//if(cnt[spot]>=n)
				//{
				//	suc= 1;
				// 	return;
				//}
				dis[spot] = dis[now]+w;
				if(vis[spot]==0)
				{
					vis[spot]=1;
					q.push(spot);
				}
			} 
		}
	}
}
int main()
{
	IOS;
	cin>>n>>m;
	while(m--)
	{
		int a,b,w;
		cin>>a>>b>>w;
		v[a].pb({b,w});
		//v[b].pb({a,w});//双向边时候加上
	}
	cin>>s;//s为初始起点
	spfa(s);
}

P3371 【模板】单源最短路径（弱化版）

#include<bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define PII pair<int,int >
#define IOS std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
using namespace std;
const int N = 1e6+10;
int n,m,s;
vector< pair<int,int> > v[N];//v[s][i].fi是初始点s能走到的第i个的点，v[s][i].se初始点s能走到 
int dis[N];//是从初始点s到第i个点的最短路程 
bool vis[N];//标记该点是否被走过了 
void spfa()
{
	for(int i=1;i<=n;i++)
	{
		dis[i] = 1e9;
		vis[i] = 0;	
	}
	queue<int> q;
	q.push(s);
	dis[s] = 0;
	vis[s] = 1;
	while(q.size())
	{
		int now = q.front();
		q.pop();
		vis[now] = 0;
		for(auto t:v[now])
		{
			int spot = t.fi,w =t.se;
			if(dis[spot]>dis[now]+w)
			{
				dis[spot] = dis[now]+w; 
				if(vis[spot]==0)
				{
					vis[spot] = 1;
					q.push(spot);
				} 
			}
		}
	}
}
int main()
{
	IOS;
	cin>>n>>m>>s;
	while(m--)
	{
		int a,b,c;
		cin>>a>>b>>c;
		v[a].pb({b,c});
		//v[b].pb({a,c});加上为无向边，不加为单向边 
	}
	spfa();
	for(int i=1;i<=n;i++)
	{
		if(dis[i]==1e9) cout<<(1ll<<31)-1<<' ';
		else cout<<dis[i]<<" ";
	}
	
}

P3385 【模板】负环

#include<bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define PII pair<int,int >
#define IOS std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
using namespace std;
const int N = 1e6+10;
int n,m;
bool vis[N];
int dis[N];
int cnt[N];//1.加个数组
vector<PII> v[N];
//2.cnt[i]表示走到第i个点时用了几条边,一般最大为n-1条,如果存在负环, 则会>=n  
bool spfa()//3.改为bool 
{
	queue<int> q;
	for(int i=1;i<=n;i++)
	{
		dis[i] = 1e9;
		vis[i] = 0;
		cnt[i] = 0;//查负环时加上
	}//初始化
	vis[1] = 1;
	dis[1] = 0; 
	q.push(1);
	while(q.size())
	{
		int now = q.front();
		q.pop();
		vis[now] = 0;
		for(auto t:v[now])
		{
			int spot = t.fi,w = t.se;
			if(dis[spot]>dis[now]+w)
			{
				cnt[spot] = cnt[now]+1;//4.记录已用环数 
				if(cnt[spot]>=n) return true; //5.一定要返回,不然会一直重复去加负权 
				                            //如 5 -> 6边权为2, 6 -> 5边权为-3,便会一直+2-3下去，越加越爽，爽到负无穷  
				                               
				dis[spot] = dis[now]+w;
				if(vis[spot]==0)
				{
					q.push(spot);
					vis[spot]=1;
				}
			}
		}
	}
	return false;//6.没有负环 
}
int main()
{
	IOS;
	int k;
	cin>>k;
	while(k--)
	{
		cin>>n>>m;
		for(int i=1;i<=max(n,m);i++)
		{
			v[i].clear();//多组数据时加上
			dis[i] = 1e9;
			vis[i] = 0;
			cnt[i] = 0;
		}
		while(m--)
		{
			int a,b,c;
			cin>>a>>b>>c;
			if(c>=0) v[a].pb({b,c}),v[b].pb({a,c});
			else v[a].pb({b,c});
		}
		if(spfa()) cout<<"YES"<<"\n";
		else cout<<"NO"<<"\n";
	} 

}

那如果存在非连通的点呢？

	//从原点n+1开始搜
	bool spfa()//3.改为bool 
{
	queue<int> q;
	for(int i=1;i<=n;i++)
	{
		dis[i] = 1e9;
		vis[i] = 0;
		cnt[i] = 0;//查负环时加上
	}//初始化
	vis[n+1] = 1;//从原点n+1开始搜，详情见7.--- 
	dis[n+1] = 0; 
	q.push(n+1);
} 
int main()
{
	for(int i=1;i<=n;i++)//7.注意!!如果各点可能不是全部连通，如果从1开始会搜不到另一部分的负权
	{                    //所以建立一个点把所有点连接起来，我们就设它为n+1
		v[n+1].pb({i,0});//从n+1开始到所有的点，边权为零不会影响结果 
	}
}

P3905 道路重建

#include<bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define PII pair<int,int >
#define IOS std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
using namespace std;
const int N = 1e6+10;
int n,m,d,A,B;
int dis[N];
bool vis[N];
vector<PII> v[N];
map<pair<int,int>,int> mp;
void spfa()
{
	for(int i=1;i<=n;i++)
	{
		dis[i] = 1e9;
		vis[i] = 0;
	}//初始化
	queue<int> q;
	q.push(A);
	dis[A] = 0;
	vis[A] = 1;
	while(q.size())
	{
		int now = q.front();
		q.pop();
		vis[now] = 0;
		for(auto t:v[now])
		{
			int spot = t.fi,w = 0;  
			if(mp[{now,spot}]==1) w = t.se;//这条路如果被炸过了，那么就把他的长度算上，去修它 
			if(dis[spot]>dis[now]+w)
			{
				dis[spot] = dis[now]+w; 
				if(vis[spot]==0)
				{
					vis[spot] = 1;
					q.push(spot);
				} 
			}
		}
	}
}
int main()
{
	IOS;
	cin>>n>>m;
	while(m--)
	{
		int a,b,c;
		cin>>a>>b>>c;
		v[a].pb({b,c});
		v[b].pb({a,c});
	}
	cin>>d;
	while(d--)
	{
		int a,b;
		cin>>a>>b;
		mp[{a,b}] = 1;//标记a -> bb不能走 
		mp[{b,a}] = 1;//b -> a不能走 
	}
	cin>>A>>B;
	spfa();
	cout<<dis[B];
}

P1629 邮递员送信

#include<bits/stdc++.h>
#define ll long long
#define fi first
#define se second
#define pb push_back
#define PII pair<int,int >
#define IOS ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
using namespace std;
const int N = 1e6+10;
int n,m;
vector<PII> v1[N];
vector<PII> v2[N];
bool vis1[N];
int dis1[N];
bool vis2[N];
int dis2[N];
int sum=0;
void spfa1(int s)
{
	queue<int> q;
	vis1[s] = 1;
	for(int i=1;i<=n;i++)
	{
		dis1[i] = 1e9;
		vis1[i] = 0;
	}//初始化
	dis1[s] = 0;
	q.push(s);
	while(q.size())
	{
		int now = q.front();
		q.pop();
		vis1[now] = 0;
		for(auto t:v1[now])
		{
			int spot = t.fi,w = t.se;
			if(dis1[spot]>dis1[now]+w)
			{
				dis1[spot] = dis1[now]+w;
				if(vis1[spot]==0)
				{
					vis1[spot] = 1;
					q.push(spot);
				}
			}
		}
	}
}
void spfa2(int s)
{
	queue<int> q;
	vis2[s] = 1;
	for(int i=1;i<=n;i++)
	{
		dis2[i] = 1e9;
		vis2[i] = 0;
	}//初始化
	dis2[s] = 0;
	q.push(s);
	while(q.size())
	{
		int now = q.front();
		q.pop();
		vis2[now] = 0;
		for(auto t:v2[now])
		{
			int spot = t.fi,w = t.se;
			if(dis2[spot]>dis2[now]+w)
			{
				dis2[spot] = dis2[now]+w;
				if(vis2[spot]==0)
				{
					vis2[spot] = 1;
					q.push(spot);
				}
			}
		}
	}
}
int main()
{
	IOS;
	cin>>n>>m;
	while(m--)
	{
		int a,b,l;
		cin>>a>>b>>l;
		v1[a].pb({b,l});
		v2[b].pb({a,l});//从所有的点走到1的路径，反向建边，让1替他们走一遍，避免了每个点都调用一次spfa导致超时
	} 
	spfa1(1);
	spfa2(1);
	for(int i=1;i<=n;i++)
	{
		sum+=dis1[i];
		sum+=dis2[i];
	}
	cout<<sum;
}

P2136 拉近距离

#include<bits/stdc++.h>
#define ll long long
#define fi first
#define se second
#define pb push_back
#define PII pair<int,int >
#define IOS ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
using namespace std;
const int N = 1e6+10;
int n,m,T;
int cnt[N];
bool vis[N];
int dis[N];
vector<PII> v[N];
bool suc = 0;
void spfa(int s)
{
	queue<int> q;
	for(int i=1;i<=n;i++)
	{
		dis[i] = 1e9;
		vis[i] = 0;
		cnt[i] = 0;
	}
	vis[s] = 1;
	dis[s] = 0;
	q.push(s);
	while(q.size())
	{
		int now = q.front();
		q.pop();
		vis[now] = 0;
		for(auto t:v[now])
		{
			int spot = t.fi,w = t.se;
			if(dis[spot]>dis[now]-w)
			{
				cnt[spot] = cnt[now]+1;
				if(cnt[spot]>=n)
				{
					suc= 1;
				 	return;
				}
				dis[spot] = dis[now]-w;
				if(vis[spot]==0)
				{
					vis[spot]=1;
					q.push(spot);
				}
			}
		}
	}
}
int main()
{
	IOS;
	cin>>n>>m;
	while(m--)
	{
		int a,b,w;
		cin>>a>>b>>w;
		v[a].pb({b,w});
	}
	int minn=1e9;
	spfa(1);
	minn = min(minn,dis[n]);
	spfa(n);//小红也会干事情来拉近距离 ，靠!!!! 
	minn = min(minn,dis[1]);
	if(suc) cout<<"Forever love";
	else cout<<minn;
}
Mr.Z.411
关注
  • 8
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
dlut1219-spfa+二维dis
成为大soft虫的梦想屋
03-31 608
题目： DDR Ddr   DDR口头禅： 我要征服地球！   星座：魔蝎座 生日：12月22日 血型：不明 年龄：不明 生肖：不明 身高：139公分 体重：37公斤       职业：不明 兴趣：看科幻电影 宠物：龟鸟（来自DR星的小生物） 最喜欢：开UFO飙飞 最讨厌：记者用闪光照相机给它拍照 偶像：ET外星人 语言：中文      
最短路（SPFA）
booyoungxu的专栏
07-28 594
算法特点（权值可正可负，判断负环） 1.用来求解单源最短路径，源点到任意点的最短路。 2.算法介绍：建立一个队列q，初始时队列里只有一个起始点，在建立一个数组dis记录起始点到所有点的最短路径，并且初始化这个数组。然后进行松弛操作，用 队列里面的点去刷新起始点到所有点的最短路，如果刷新成功且刷新点不再队列中则把该点加入到队列最后，重复执行直到队列为空。 3.时间复杂度：O(ke),k指的是所
Aizu 2249 单源最短路变形 spfa模板改写
ACM,再见！
06-22 671
http://vjudge.net/contest/view.action?cid=48211#problem/F Description King Mercer is the king of ACM kingdom. There are one capital and some cities in his kingdom. Amazingly, there are no road
spfa求最短路
m0_46370829的博客
07-18 383
大雪菜的课（笔记） 搜索与图论（二） 1.最短路 (4).spfa求最短路 模板 spfa 算法（队列优化的Bellman-Ford算法） —— 模板题 AcWing 851. spfa求最短路 时间复杂度 平均情况下 O(m)，最坏情况下 O(nm), n 表示点数，m 表示边数 int n; // 总点数 int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边 int dist[N]; // 存储每个点到1号点的最短距离 boo
0基础学图论！——图论精讲/详细/新手理解概念必看！
Like_Ginger的博客
07-15 1670
并不会有更好的阅读体验 特别特别感谢： lmpplmpplmpp大佬牺牲自己宝贵时间，为我没有脾气的耐心讲解。 BeyondHeavenBeyondHeavenBeyondHeaven大佬，无偿帮我康博客，甚至和我这个陌生的蒟蒻分享自己的故事，带给了我知识和温暖。真的、真的非常谢谢宁！qwqqwqqwq FlyFlyFly_FunnyFunnyFunny大佬，理会了一个无关紧要的人的丧气话，并且带给了她把这篇博文更完的动力。 真的很感谢我的教练diddiddid，他的宽容友爱和超一流的教学水准不仅让我迈上了
常用算法代码。。。。。。。。。。
02-01
##### BELLMANFORD单源最短路O(VE) - **定义**：适用于含负权重边的图，求解单源最短路径问题。 - **应用场景**： - 财务网络中的资金转移成本计算。 - 供应链管理中的物流成本估算。 - **关键步骤**： 1. 初始化...
kubectl 创建pvc_K8S 使用NFS 创建PV和PVC的例子 学习From https://blog.csdn.net/xts_huangxin/article/details/5149...
weixin_39966376的博客
12-19 269
1. 获取资料 网址:https://blog.csdn.net/xts_huangxin/article/details/51494472 感谢原作者 这里面 按照自己的机器情况进行了学习模仿 并且mark一下.2. 下载yaml 文件:https://github.com/FlyingShit-XinHuang/my-doc/blob/master/k8s/pv%26pvc/nfs.zip...
CSP前的常见错误分析
Michael_GLF的博客
11-12 5861
就是一个菜鸡的总结 1.代码类 1.有时候不开long long，所以以防万一只要有开long long的可能就直接全局long long，就是有时候需要注意内存。 2.字符串的读入总是令人智熄，所以可能的话统一用scanf，像类似线段树输入操作的时候就直接开一个字符数组，这样就不会被空格啊行末回车啊什么的按在地上摩擦。（PS：有字符数组的读入好像不能用fread了？） 3.调试语句一定要...
洛谷【T282123】电路维修
HeHe_xyz的博客
10-12 172
翰翰的家里有一辆飞行车。有一天飞行车的电路板突然出现了故障，导致无法启动。 电路板的整体结构是一个 R 行 C 列的网格（R,C≤500），如下图所示。每个格点都是电线的接点，每个格子都包含一个电子元件。 电子元件的主要部分是一个可旋转的、连接一条对角线上的两个接点的短电缆。 在旋转之后，它就可以连接另一条对角线的两个接点。电路板左上角的接点接入直流电源，右下角的接点接入飞行车的发动装置。达达发现因为某些元件的方向不小心发生了改变，电路板可能处于断路的状态。
【C++】STL—vector的使用
2301_77112794的博客
09-04 679
本文介绍了vector重点函数接口的使用
C语言 | Leetcode C语言题解之第389题找不同
m0_59237910的博客
09-07 439
C语言 | Leetcode C语言题解之第389题找不同
C语言 ——— #define 定义宏
weixin_55341642的博客
09-04 814
a + b 的和 于 b - a 的差 做乘法，a + b = 8 ，b - a = 2。#define 机制包括了一个规定，允许把参数替换到文本中，这种实现通常称宏。在宏中的每个变量都加上了括号，加上括号的意义在哪，是否能去掉括号呢？所以在声明宏的时候，最好加上必要的括号，以免出现优先级问题。可以从代码验证中看出，不加括号的结果和预期的结果大相径庭。预期结果：8 * 2 = 16。
C语言初阶 --- ⾃定义类型：结构体
2301_79842589的博客
09-08 731
💫往期文章👇：
关于C语言中实参与形参和指针与二级指针的理解
2203_75904043的博客
09-04 401
在如下代码中，我的test函数要将结构体指针作为实参传递给function函数插入值，那么为什么必须传递二级指针才能正确进行插入呢。
[ C++ ] 一文复习（基础语法，语言特性，STL回顾）
2301_79175236的博客
09-04 997
C++复习参考文，待完善
c++ 类的继承详解
HJQD777的博客
09-07 398
继承允许类之间建立层次关系，促进代码重用和扩展。继承有不同的访问控制方式（publicprotectedprivate），影响派生类对基类成员的访问权限。基类的构造函数和析构函数不会被继承，派生类需要自行定义。使用虚函数和多态可以实现灵活的接口设计和动态方法调用。理解继承机制对于设计高效、灵活和可维护的面向对象系统至关重要。
从C到C++
最新发布
D1557329860的博客
09-08 603
string不是C++的基本数据类型，它是一个C++标准库中的字符串类，使用时需要引入对应的头文件，#include<string>，而不是string.h.引用参数，在不参与计算的情况下，我们建议使用const进行修饰，以达到引用的安全性。声明引用的时候，初始化的值可以是纯数值，但是此时需要使用const关键字修饰，表示该引用为常量引用，这样引用的值不可变。写一个函数，函数有两个参数a和b，函数的功能是交换两个传入的参数原来变量的值。可以使用const修饰引用，此时如果原变量的值改变，引用的值也改变。
C/C++ 获取 linux 的所有 USB声卡ID及其信息
lijian2017的博客
09-04 1099
popen()在 Linux 下，要获取 USB 声卡的 ID 和名称信息，通常你需要结合多个系统命令和接口，因为 C/C++ 标准库本身并不直接提供这样的功能。下面我将给出一个大致的方向，展示如何通过执行系统命令或使用 Linux 特有的库来实现这一目标。
Java最短路SPFA
03-31
SPFA算法是一种求解最短路的算法，它是基于Bellman-Ford算法的改进版。与Bellman-Ford算法不同的是，SPFA算法将每个节点的更新顺序改为了队列中的任意顺序。这样可以减少不必要的松弛操作，从而提高算法的效率。以下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值