判断负环的方法。

最新推荐文章于 2023-08-08 21:46:45 发布
最新推荐文章于 2023-08-08 21:46:45 发布
阅读量3.5k 收藏 15
点赞数 5
分类专栏： 程序设计竞赛记录
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40482358/article/details/86748585
版权

判断负环，也是一个小知识点了，之前一直比较迷，现在总结一下，再加一些板子，以后直接用了就。

判断负环，最常用的就是bellman-floy和spfa，暴力枚举/奇怪的贪心/超神搜索，这些算法了，但是因为要一般性，那些玄学算法就是放弃吧（难道真实原因不是非洲人没有玄学算法吗

Bellman-ford

两个神仙提出来的算法，据说一个好像还是动态规划的发明者（真神仙），

这个算法的思路就是，从源开始，初始化所有距离为INF||0...（视情况而定），然后将源置为0||val...

进行（n-1）*m次松弛判断，并且刷新结果。

之后再进行m次判断，如果仍存在一个点可被松弛，那么就说明这个存在负环。

代码如下：

#include<iostream>
using namespace std;
const int MAXN=1e5+10;
const int INF=0x3f3f3f3f;
struct node{
	int u,v,val;
	node(int _u=0,int _v=0,int _val=0){
		u=_u;v=_v;val=_val;
	}
}edge[MAXN];
int dis[MAXN];
int n,m;

int bellman_ford(){
	memset(dis,INF,sizeof(dis));dis[1]=0;
	for(int i=1;i<n;++i){
		for(int j=1;j<=m;++j){
			if(dis[edge[j].v]>dis[edge[j].u]+edge[j].val){
				dis[edge[j].v]=dis[edge[j].u]+edge[j].val;
			}
		}
	}int f=1;
	for(int j=1;j<=m;++j){
		if(dis[edge[j].v]>dis[edge[j].u]+edge[j].val){
			f=0;break;
		}
	}return f;
}
int main(){
	cin>>n>>m;
	for(int i=1;i<=m;++i){
		cin>>edge[i].u>>edge[i].v>>edge[i].val;
	}
	if(!bellman_ford())	cout<<"存在负环"<<endl;
	else				cout<<"不存在负环"<<endl;
}

SPFA

关于SPFA，它死了。

既然死了，就不需要再看了。

说笑说笑，SPFA哪怕日常被T，但是仍有着存在的价值的。下面写一个DFS_SPFA的板子，从1开始的负环判断（题面）


const int MAXN=3e3+10;
const int INF32=0x3f3f3f3f;
const ll INF64=0x3f3f3f3f3f3f3f3f;
const ll mod=1e9+7;
const double PI=acos(-1.0);
struct node{
	int v,w,cost,nxt;
	node(int _v=0,int _w=0,int _nxt=0):
    v(_v),w(_w),nxt(_nxt){}
}edge[MAXN<<1];
int head[MAXN],ecnt;
int dis[MAXN],vis[MAXN];
int n,m,f;

void add(int u,int v,int w){
	edge[ecnt]=node(v,w,head[u]);
	head[u]=ecnt++;
}
void dfs_spfa(int u){
	vis[u]=1;
	for(int i=head[u];i+1;i=edge[i].nxt){
		int v=edge[i].v;
		if(dis[u]+edge[i].w<dis[v]){
			dis[v]=dis[u]+edge[i].w;
			if(vis[v]){
				f=1;return ;
			}
			else		dfs_spfa(v);
		}
	}vis[u]=0;
}
int main(){
	int T;cin>>T;
	while(T--){
		clean(head,-1);clean(dis,INF32);clean(vis,0);
		dis[1]=0;ecnt=0;
		int n,m;cin>>n>>m;
		int a,b,val;
		for(int i=1;i<=m;++i){
			cin>>a>>b>>val;
			add(a,b,val);
			if(val>=0)	add(b,a,val);
		}f=0;
		dfs_spfa(1);
		if(f)	cout<<"YE5"<<endl;
		else			cout<<"N0"<<endl;
	}
}

更新一个手写栈的实现代码，最近光用手写的栈了，感觉还是手写的比较舒服一点：

void dfs_spfa(){
	clean(dis,INF32);dis[1]=0;
	clean(vis,0);vis[1]=1;
	clean(sum,0);sum[1]++;
	st[tot++]=1;
	while(tot){
		int u=st[--tot];vis[u]=0;
		for(int i=head[u];i+1;i=edge[i].nxt){
			int v=edge[i].v;
			if(dis[v]>dis[u]+edge[i].val){
				dis[v]=dis[u]+edge[i].val;
				if(vis[v]==0){
					vis[v]=1;
					st[tot++]=v;
					sum[v]++;
					if(sum[v]>=n){
						flag=1;return ;
					}
				}
			}
		}
	}
}

然后事BFA_SPFA的板子：

const int MAXN=3e3+10;
const int INF32=0x3f3f3f3f;
const ll INF64=0x3f3f3f3f3f3f3f3f;
const ll mod=1e9+7;
const double PI=acos(-1.0);

struct node{
	int v,w,cost,nxt;
	node(int _v=0,int _w=0,int _nxt=0):
    v(_v),w(_w),nxt(_nxt){}
}edge[MAXN<<1];
int head[MAXN],ecnt;
int dis[MAXN],vis[MAXN],cnt[MAXN];
int n,m;

void intt(){
	clean(head,-1);
	clean(dis,INF32);
	clean(vis,0);
	clean(cnt,0);
	ecnt=0;
}
void add(int u,int v,int w){
	edge[ecnt]=node(v,w,head[u]);
	head[u]=ecnt++;
}
int bfs_spfa(int u){
	queue<int> que;que.push(u);
	vis[u]=1;dis[u]=0;
	while(que.size()){
		int e=que.front();que.pop();
		vis[e]=0;
		if(cnt[e]>=n)	return 1;
		for(int i=head[e];i+1;i=edge[i].nxt){
			int temp=edge[i].v;
			if(dis[temp]>dis[e]+edge[i].w){
				dis[temp]=dis[e]+edge[i].w;
				if(vis[temp]==0){
					que.push(temp);
					vis[temp]=1;cnt[temp]++;
					if(cnt[temp]>=n)	return 1;
				}
			}
		}
	}return 0;
}
int main(){
	int T;cin>>T;
	while(T--){
		intt();
		cin>>n>>m;
		int a,b,val;
		for(int i=1;i<=m;++i){
			cin>>a>>b>>val;
			add(a,b,val);
			if(val>=0)	add(b,a,val);
		}
		if(bfs_spfa(1))	cout<<"YE5"<<endl;
		else			cout<<"N0"<<endl;
	}
}

然后是根据这个两个板子写的两个题：

洛谷P3385：https://www.luogu.org/problemnew/show/P3385

这是一个单纯的板子题，用来检验板子的正确性的一道题。直接判断是否存在负环。

//#pragma comment(linker, "/STACK:1024000000,1024000000") 
 
#include<stdio.h>
#include<string.h>  
#include<math.h>  
  
#include<map>   
//#include<set>
#include<deque>  
#include<queue>  
#include<stack>  
#include<bitset> 
#include<string>  
#include<fstream>
#include<iostream>  
#include<algorithm>  
using namespace std;  
 
#define ll long long  
#define Pair pair<int,int>
//#define max(a,b) (a)>(b)?(a):(b)
//#define min(a,b) (a)<(b)?(a):(b) 
#define clean(a,b) memset(a,b,sizeof(a))// ?? 
//std::ios::sync_with_stdio(false);
const int MAXN=3e3+10;
const int INF32=0x3f3f3f3f;
const ll INF64=0x3f3f3f3f3f3f3f3f;
const ll mod=1e9+7;
const double PI=acos(-1.0); 

struct node{
	int u,v,val;
	node(int _u=0,int _v=0,int _val=0){
		u=_u;v=_v;val=_val;
	}
}edge[MAXN];
int dis[MAXN];
int n,m,s,t,ecnt;

int bellman_ford(){
	//clean(dis,INF32);dis[1]=0;
	for(int i=1;i<=n;++i){
		for(int j=1;j<=m;++j){
			if(dis[edge[j].v]>dis[edge[j].u]+edge[j].val){
				dis[edge[j].v]=dis[edge[j].u]+edge[j].val;
			}
			if(edge[j].val>=0&&dis[edge[j].u]>dis[edge[j].v]+edge[j].val){
				dis[edge[j].u]=dis[edge[j].v]+edge[j].val;
			}
		}
	}int f=1;
	for(int i=1;i<=m;++i){
		if(dis[edge[i].v]>dis[edge[i].u]+edge[i].val){
			f=0;break;
		}
		if(edge[i].val>=0&&dis[edge[i].u]>dis[edge[i].v]+edge[i].val){
			f=0;break;
		}
	}return f;
}
int main(){
	int T;
	cin>>T;
	while(T--){
		ecnt=0;
		cin>>n>>m;
		int a,b,val;
		for(int i=1;i<=m;++i){
			cin>>edge[i].u>>edge[i].v>>edge[i].val;
		}
		if(!bellman_ford())	cout<<"YE5"<<endl;
		else				cout<<"N0"<<endl;
	}
}
 
/*

*/

POJ-1860：http://poj.org/problem?id=1860

钱币兑换的发财之道

这是一个判断是否存在一个正权回路的，一样的思路：

AC：

#include<stdio.h>
#include<string.h> 
#include<math.h> 
 
#include<map>  
#include<set>
#include<deque> 
#include<queue> 
#include<stack> 
#include<bitset>
#include<string> 
#include<fstream>
#include<iostream> 
#include<algorithm> 
using namespace std; 
 
#define ll long long 
#define Pair pair<double,double>
//#define max(a,b) (a)>(b)?(a):(b)
//#define min(a,b) (a)<(b)?(a):(b)
#define clean(a,b) memset(a,b,sizeof(a))// 水印
//std::ios::sync_with_stdio(false);
//  register
const int MAXN=1e5+10;
const int INF32=0x3f3f3f3f;
const ll INF64=0x3f3f3f3f3f3f3f3f;
const ll mod=1e9+7;
const double PI=acos(-1.0);

struct node{
	int u,v;double cost,Comp;
	node(int _u=0,int _v=0,double _cost=0,double _Comp=0){
		u=_u;v=_v;
		cost=_cost;Comp=_Comp;
	}
}arr[MAXN];
double dis[MAXN];
int n,m,ecnt;

int bellman_ford(int s,double have){
	dis[s]=have;
	for(int i=1;i<n;++i){
		for(int j=0;j<ecnt;++j){
			if(dis[arr[j].v]<(dis[arr[j].u]-arr[j].Comp)*arr[j].cost){
				dis[arr[j].v]=(dis[arr[j].u]-arr[j].Comp)*arr[j].cost;
			}
		}
	}int f=1;
	for(int i=0;i<ecnt;++i){
		if(dis[arr[i].v]<(dis[arr[i].u]-arr[i].Comp)*arr[i].cost){
			f=0;break;
		}
	}return f;
}
int main(){
	int kind;double have;
	cin>>n>>m>>kind>>have;
	ecnt=0;
	int a,b;double Rab,Cab,Rba,Cba;
	for(int i=1;i<=m;++i){
		cin>>a>>b>>Rab>>Cab>>Rba>>Cba;
		arr[ecnt++]=node(a,b,Rab,Cab);
		arr[ecnt++]=node(b,a,Rba,Cba);
	}
	if(!bellman_ford(kind,have))	cout<<"YES"<<endl;
	else							cout<<"NO"<<endl;
	
}

然后是POJ-2240-Arbitrage

题目链接：http://poj.org/problem?id=2240

跟上一道题是一个意思，只不过这个换成字符串了，dfs-spfa判断走一波

AC：

//#pragma comment(linker, "/STACK:1024000000,1024000000") 
 
#include<stdio.h>
#include<string.h>  
#include<math.h>  
  
#include<map>   
//#include<set>
#include<deque>  
#include<queue>  
#include<stack>  
#include<bitset> 
#include<string>  
#include<fstream>
#include<iostream>  
#include<algorithm>  
using namespace std;  
 
#define ll long long  
#define Pair pair<int,int>
//#define max(a,b) (a)>(b)?(a):(b)
//#define min(a,b) (a)<(b)?(a):(b) 
#define clean(a,b) memset(a,b,sizeof(a))// ?? 
//std::ios::sync_with_stdio(false);
const int MAXN=35;
const int INF32=0x3f3f3f3f;
const ll INF64=0x3f3f3f3f3f3f3f3f;
const ll mod=1e9+7;
const double PI=acos(-1.0); 

double mp[MAXN][MAXN];
double dis[MAXN];
int vis[MAXN];
map<string,int> mp1;
int n,m,f;

void intt(){
	for(int i=0;i<MAXN;++i){
		for(int j=i;j<MAXN;++j){
			mp[i][j]=mp[j][i]=0;
		}dis[i]=-1;
	}mp1.clear();clean(vis,0);
}
void dfs_spfa(int u){
	vis[u]=1;
	for(int i=1;i<=n;++i){
		if(dis[i]<dis[u]*mp[u][i]){
			dis[i]=dis[u]*mp[u][i];
			if(vis[i]){
				f=1;return ;
			}
			else{
				dfs_spfa(i);
			}
		}
	}vis[u]=0;
}
int main(){
	int Case=1;
	while(cin>>n){
		if(n==0)	break;
		intt();
		string kind;int k=1;
		for(int i=1;i<=n;++i){
			cin>>kind;
			if(mp1[kind]==0)	mp1[kind]=k++;
		}cin>>m;
		string kind2;double rate;
		for(int i=1;i<=m;++i){
			cin>>kind>>rate>>kind2;
			if(mp[mp1[kind]][mp1[kind2]]<rate)//更大 
				mp[mp1[kind]][mp1[kind2]]=rate;
		}
		dis[1]=1;f=0;
		dfs_spfa(1);
		if(f)	cout<<"Case "<<Case++<<": Yes"<<endl;
		else				cout<<"Case "<<Case++<<": No"<<endl;
	}
}
 
/*

*/

 

永远鲜红の幼月
关注
  • 5
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
简述色环电阻识别方法
08-20
此时，可以通过以下几点来判断第一环的位置：1)偏差环与其他环距离较远；2)偏差环较宽；3)第一环离电阻端部较近；4)有效数字环不包含金色和银色；5)偏差环不是橙色或黄色；6)尝试读取阻值，如果超过22MΩ，可能读反...
滞环比较器在电源中的应用
01-20
电源中的恒流恒压是通过运放接成负反馈来实现，同时也存在着一种结构和运放很相似的装置，是为了实现保护目的的，那就是比较器。比较器有很多种，常用的有像单滞环比较器、双滞环比较器。在这里列出几种，说明一下...
spfa算法判断负环【什么是负环】【出现负环会怎么样】【牢记，此时不是求最短路】
蓝天it（让亿万孩子在蓝天下共享优质教育）
12-04 901
spfa算法判断负环【什么是负环】【出现负环会怎么样】【牢记，此时不是求最短路】
负环——spfa判断负环的两种方式
测试
09-27 1550
统计当前每个点的最短路的边数，如果存在负环，负环上的某一个点的最短路边数一定会是正无穷，只要边数超过n(节点数)，就可以判断存在负环。图并不是全部连通，存在单独一个点没有入度和出度。这时候就不能只从某一个点进去找，有可能根本更新不到其他点。统计每个点的入队次数，如果某一个点入队了n次，则说明存在负环。但以上这个方法被硬卡数据有可能超市，可以尝试。这时候可以假设一个虚拟源点与所有的点都相连，并且距离为零。一次把所有点入队，后续更新就可以检测出负环。
判断负环算法
qq_41729237的博客
07-17 1065
负环的定义 负环是指权值和为负数的环。负环会使图的最短路径计算陷入死循环，因此，存在负环的图不存在最短路。 负环的计算方法： 负环有两种计算方法，都是基于Bellman-Ford算法或者SPFA算法。 第一种算法是：统计每个点的入队次数，如果某个点入队大于等于n次，则说明有负环 第二种算法是：统计到某个点的最短路所经过点的个数，如果经过n个点，则说明存在负环。 ...
【学习笔记】如何正确判负环
changle_cyx
07-07 1074
最近发现自己不太会判负环。 以下是两种科学的判负环方法，方法一的实际效率应当是比方法二快的。 方法一： 在 SPFA\text{SPFA}SPFA 的过程中顺便记一个变量 cnt[x]cnt[x]cnt[x] ，表示 1→x1\to x1→x 的最短路上经过的边数，在松弛时顺带判断，若存在一个点 xxx 满足 cnt[x]≥ncnt[x]\ge ncnt[x]≥n，则图中存在负环。 方法二： 在...
负环判断（SPFA）
jkchen's Haven
02-19 842
原题： https://www.luogu.org/problemnew/show/P3385 题意： n个点，m条边，判断是否存在负环。(输出YE5不是YES，N0不是NO) 解析： 这个题目真的是累，网上也没多少正确的题解，说的一些我都懂，但是时间复杂度不优秀。在洛谷和csdn上找了好久。真的是，洛谷时间复杂度前几的只有两种算法。第一种：百来行的建树做的，很优秀but看不懂；第二种：speci...
判断负环
weixin_34198762的博客
02-13 183
/*判断负环的两种方法:Spfa思想:如果存在一个点进入队列的次数超过N次，则存在负环。bellman_ford思想：对所有的边进行v-1松弛即如果dis[u]+map[u][v]<dis[v]则dis[v]=dis[u]+map[u][v]若v-1次松弛之后还能进行松弛，说明原图存在负环。复杂度0(VE)*///bellman_ford判断#in...
比较两种滞环比较器在电源中的应用
01-20
电源中的恒流恒压是通过运放接成负反馈来实现，同时也存在着一种结构和运放很相似的装置，是为了实现保护目的的，那就是比较器。比较器有很多种，常用的有像单滞环比较器、双滞环比较器。在这里列出几种，说明一下...
JavaScript基于正则表达式的数字判断函数
12-13
在JavaScript程序中，我们可以使用`test()`方法结合正则表达式来判断字符串是否符合特定的数字格式。例如： ```javascript var r = /^[0-9]*[1-9][0-9]*$/; // 正整数的正则表达式 var str = "123"; r.test(str); /...
...............判断π电子的方法
03-21
标题中的“判断π电子的方法”是指在化学领域中，如何确定分子或离子中π电子的数量，这在理解和评估分子的芳香性以及其化学性质时至关重要。描述提到了休克尔规则，这是判断芳香性的一个标准。 休克尔规则是德国...
SPFA判负环
forever_dreams的博客
07-29 9745
知识点系列之---SPFA判负环
spfa判断负环
weixin_46047677的博客
03-24 2046
求负环的常用方法，基于SPFA 方法 1：统计每个点入队的次数，如果某个点入队n次，则说明存在负环 方法 2：统计当前每个点的最短路中所包含的边数，如果某点的最短路所包含的边数大于等于n，则也说明存在环 在SPFA的基础上 加一个cnt数组来记录当前 x 点到 虚拟源点 最短路的边数，初始每个点到虚拟源点的距离为0，只要他能再走n步，即 cnt[x] >= n ，则表示该图中一定存在负环，由于从虚拟源点到x至少经过n条边时，则说明图中至少有n + 1个点，表示一定有点是重复使用 C++代码
负环和0/1分数规划学习笔记
最新发布
Rainbow_Cat_M的博客
08-08 48
对于判负环问题，我们需要一个超级源点，保证图中的每一条边都可以遍历到，因此我们建立一个超级源点，让超级源点与个点分别连一条权值为的边。实际上，我们在代码实现时可以省去超级源点与个点连边的这一步，我们直接将这个点加入到队列当中。i<=n;
判断是否存在负环
yihanyifan的博客
05-03 1473
第1行：一个整数F表示接下来会有F个农场说明。每个农场第一行：分别是三个空格隔开的整数：N，M和W 第2行到M+1行：三个空格分开的数字（S，E，T）描述，分别为：需要T秒走过S和E之间的双向路径。两个区域可能由一个以上的路径来连接。第M +2到M+ W+1行：三个空格分开的数字（S，E，T）描述虫洞，描述单向路径，S到E且回溯T秒。 23 3 11 2 21 3 42 3 13 1 33 2 1...
图论学习-负环
麒麟001号的博客
03-03 1408
文章目录一、负环 acwing提高课正好看到负环，干脆写篇博客记录一下。 一、负环 定义：环中所有边权值和为负数的环，称为负环 负环可以有两种求法：bellman_ford和spfa spfa是对bellman_ford的优化，一般是用spfa求负环 时间复杂度最好O(m),最坏O(km) 给出判负环的两种方法： (1) 统计每个点入队次数，如果某个点入队n次，说明存在n条边的路径，那么必然有n+1个点，则存在负环 (2) 只要某个点最短路所含的边数大于等于n，说明至少n+1个点，则存在负环 注意：
图论——负环
qq_53504307的博客
05-18 426
图论——负环 笔记： 1： 通用算法：SPFA O(m)O(m)O(m)~O(nm)O(nm)O(nm) 2： 如何判断负环？有222种方法，第111种是 Bellman-ford 判负环方法，每入队一次相当于更新一次，当入队次数 >=n>=n>=n 时 确定存在负环 ，时间复杂度 O(n2)O(n^2)O(n2) 太慢 。第222种是常用方法时间复杂度是 O(n2)O(n^2)O(n2) 统计每个点所在的最短路中边的条数。一旦边的条数 >=n>=n>=n时说明至少存在
spfa判断负环（C++）
falldeep的算法世界
07-17 502
题目 给定一个n个点m条边的有向图，图中可能存在重边和自环，边权可能为负数。 请你判断图中是否存在负权回路。 输入格式 第一行包含整数n和m。 接下来m行每行包含三个整数x,y,z，表示存在一条从点x到点y的有向边，边长为z。 输出格式 如果图中存在负权回路，则输出Yes，否则输出No。 数据范围 1≤n≤2000, 1≤m≤10000, 图中涉及边长绝对值均不超过10000。 输入样例： 3 3 1 2 -1 2 3 4 3 1 -4 输出...
负环——SPFA判断负环
Robin2321的博客
01-04 276
负环 定义：一个边权之和为负的环。 做法： 用SPFA算法，如果有一个点进了n次以上队列，那么说明存在负环。 例题 P3385 【模板】负环 P2850 [USACO06DEC]虫洞Wormholes ...
spfa如何判断负环存在
04-20
SPFA算法是一种单源最短路径算法。在使用SPFA算法求解最短路径时，如果存在负权回路，那么该问题就没有最短路径，因为可以无限次绕着这个回路走，路径长度就可以一直减小。检查负环的方法可以用SPFA算法的优化版本来实现：除了记录每个顶点的d值之外，还需要记录每个顶点进入队列的次数。如果某个顶点进入队列的次数超过了n次（其中n为图中顶点数），那么就可以判断存在负环。这是因为，一个环上至少会有一个点在队列中被处理了n次，而这个点相对于其他点的d值就会被更新了至少n次，所以就可以判断存在负环。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值