dijkstra 求最小环（ CCPC桂林 - E. Buy and Delete ）

已于 2022-04-11 17:19:01 修改
阅读量1.9k 收藏 14
点赞数 8
分类专栏： ACM笔记 图论 文章标签： 最小环
于 2022-04-11 17:18:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_dimple/article/details/124084062
版权

前言：
今天做题的时候，碰到一个有向图求最小环问题，发现除了经典的 Floyd求最小环 之外，熟知的求最短路问题的 dijkstra算法 也可以求最小环。

有向图有以下三种实现方式，而无向图只能用第一种实现方式。

实现方式1：删边求最短距离

对于一条有向边 ( u , v ) (u, v) (u,v)，可以删掉这条边（不用这条边更新）跑从 v 到 u 的最短距离，加上这条边的权值便是该边所在的最小环。

对于每条边都求一次最短路，所以时间复杂度： O ( m ∗ m l o g n ) O(m*mlogn) O(m∗mlogn)。

这种实现方法有向图无向图都可用。

有向图 Code：

#include<bits/stdc++.h>
using namespace std;

#define PII pair<int,int>
#define pb push_back
#define fi first
#define se second
#define endl '\n'

const int N = 50010, mod = 1e9+7;
int T, n, m, k;
int a[N], c;
int dist[N], f[N];
vector<PII> e[N];
int mina = 1e9; //最小环权值 

struct node{
	int x, y, w;
}b[N];

int dij(int st, int en)
{
	priority_queue<PII, vector<PII>, greater<PII> > que;
	que.push({0, st});
	
	for(int i=1;i<=n;i++) dist[i] = 1e10, f[i] = 0;
	dist[st] = 0;
	
	while(que.size())
	{
		int x = que.top().se;
		que.pop();
		
		if(f[x]) continue;
		f[x] = 1;
		
		for(auto it : e[x])
		{
			int tx = it.fi, w = it.se;
			
			if(dist[tx] > dist[x] + w)
				dist[tx] = dist[x] + w, que.push({dist[tx], tx});
		}
	}
}

signed main(){
	Ios;
	cin>>n>>m;
	
	int ans = 0;
	for(int i=1;i<=m;i++)
	{
		int x, y, z;cin>>x>>y>>z;
		e[x].pb({y, z});
		
		b[i] = {x, y, z};
	}
	
	for(int i=1;i<=m;i++)
	{
		int x = b[i].x, y = b[i].y, w = b[i].w;
		dij(y, x);
		mina = min(mina, dist[x] + w); //从y到x的最短距离加上从x到y的这条边就是这个边所在的最小环 
	}
	
	cout << mina; 
	
	return 0;
}

无向图 Code：

#include<bits/stdc++.h>
using namespace std;

#define PII pair<int,int>
#define pb push_back
#define fi first
#define se second
#define endl '\n'

const int N = 50010, mod = 1e9+7;
int T, n, m, k;
int a[N], c;
int dist[N], f[N];
vector<PII> e[N];
int pre[N];

struct node{
	int x, y, w;
}b[N];

int dij(int st, int en)
{
	priority_queue<PII, vector<PII>, greater<PII> > que;
	que.push({0, st});
	
	for(int i=1;i<=n;i++) dist[i] = 1e10, f[i] = 0, pre[i] = 0;
	dist[st] = 0;
	
	while(que.size())
	{
		int x = que.top().se;
		que.pop();
		
		if(f[x]) continue;
		f[x] = 1;
		
		for(auto it : e[x])
		{
			int tx = it.fi, w = it.se;
			if(x == st && tx == en || x == en && tx == st) continue; //st-en这条边不能走 
			
			if(dist[tx] > dist[x] + w)
				dist[tx] = dist[x] + w, que.push({dist[tx], tx}), pre[tx] = x;
		}
	}
}

signed main(){
	cin>>n>>m;
	
	for(int i=1;i<=m;i++)
	{
		int x, y, z;cin>>x>>y>>z;
		e[x].pb({y, z});
		e[y].pb({x, z});
		
		b[i] = {x, y, z};
	}
	
	stack<int> stk;
	
	int mina = 1e9;
	for(int i=1;i<=m;i++)
	{
		int x = b[i].x, y = b[i].y, w = b[i].w;
		
		dij(y, x);
		if(dist[x] + w < mina){ //记录最小环中的所有点
			mina = dist[x] + w;
			while(stk.size()) stk.pop();
			
			int t = x;
			while(t) stk.push(t), t = pre[t];
		}
	}
	
	cout << mina << endl;
	if(!stk.size()) cout<<"No solution.";
	while(stk.size()) cout << stk.top() <<" ", stk.pop();
	
	return 0;
}
有向图实现方式2：回到起点构成环

将每一个点都作为起点，跑 dijkstra。
对于每个点，从该点出发判断是否能够再回到起点，如果能，说明从该点出发能构成环。
因为是跑最短路求得的，所以这个环是 所有从起点出发回到起点的环中 权值最小的一个。
将所有点作为起点所得的最小环的最小值 便是 整张图的最小环。

每个点都跑一遍 dij，所以 时间复杂度： O ( n ∗ m l o g n ) O(n*mlogn) O(n∗mlogn)。

#include<bits/stdc++.h>
using namespace std;

#define int long long
#define PII pair<int,int>
#define pb push_back

const int N = 200010, mod = 1e9+7;
int T, n, m, k;
int a[N], c;
int dist[N], f[N];
vector<PII> e[N];
int mina = 1e18; //最小环大小

void dij(int st)
{
	priority_queue<PII, vector<PII>, greater<PII> > que;
	que.push({0, st});
	for(int i=1;i<=n;i++) dist[i] = 1e9, f[i] = 0;
	dist[st] = 0;

	while(que.size())
	{
		int x = que.top().se;
		que.pop();
		
		if(f[x]) continue;
		f[x] = 1;
		
		for(auto it : e[x])
		{
			int tx = it.first, w = it.second;
			
			if(tx == st) mina = min(mina, dist[x] + w); //下一个节点是起点，那么环的大小就是起点到当前点距离+到起点这条边的权值。
			
			if(dist[tx] > dist[x] + w)
				dist[tx] = dist[x] + w, que.push({dist[tx], tx});
		}
	}
}

signed main(){
	Ios;
	cin>>n>>m;
	
	for(int i=1;i<=m;i++)
	{
		int x, y, z;cin>>x>>y>>z;
		e[x].pb({y, z});
	}
	
	cout << mina;
	
	return 0;
}
有向图实现方法3：任意两点间的最短距离

对于每个点都跑一遍最短路，便得到任意两点间的最短距离。

那么从 x 点到 y 点的最短距离 + 从 y 点到 x 点的最短距离 便构成了一个最小环。
二重遍历所有组合，取所有环中的最小值便是整张图的最小环。

每个点都求一次最短路，所以时间复杂度： O ( n ∗ m l o g n ) O(n * mlogn) O(n∗mlogn)。

#include<bits/stdc++.h>
using namespace std;

#define PII pair<int,int>
#define pb push_back
#define fi first
#define se second

const int N = 5010, mod = 1e9+7;
int T, n, m, k;
int a[N], c;
int dist[N][N], f[N];
vector<PII> e[N];

int dij(int st)
{
	priority_queue<PII, vector<PII>, greater<PII> > que;
	que.push({0, st});
	
	for(int i=1;i<=n;i++) dist[st][i] = 1e10, f[i] = 0;
	dist[st][st] = 0;
	
	while(que.size())
	{
		int x = que.top().se;
		que.pop();
		
		if(f[x]) continue;
		f[x] = 1;
		
		for(auto it : e[x])
		{
			int tx = it.fi, w = it.se;
			
			if(dist[st][tx] > dist[st][x] + w)
				dist[st][tx] = dist[st][x] + w, que.push({dist[st][tx], tx});
		}
	}
}

signed main(){
	Ios;
	cin>>n>>m;
	
	for(int i=1;i<=m;i++)
	{
		int x, y, z;cin>>x>>y>>z;
		e[x].pb({y, z});
	}
	
	for(int i=1;i<=n;i++) dij(i);
	
	int mina = 1e9;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
		{
			if(i!=j) mina = min(mina, dist[i][j] + dist[j][i]);
		}
	
	cout << mina;
	
	return 0;
}
例题

最后附上这道题目~

题意：
A 和 B 正在玩一个游戏，给出一张图，初始只有 n 个点，没有边。

  • 起初 A 可以购买一些有向边加到图中，A 有总钱数 C C C，一共 m 条边，每条边有价格 w i w_i wi​；
  • 接下来到 B 操作，B 可以通过若干轮删边将所有边都删掉，每轮删边要满足：删掉的这些边在图中不构成环。

A 想要 B 删边的轮数尽量多，而 B 想删边的轮数尽量少。两者都采取最佳策略，问 B 要删边多少轮？

2 ≤ n ≤ 2000 , 1 ≤ m ≤ 5000 , 1 ≤ c ≤ 1 0 9 2≤n≤2000 , 1≤m≤5000, 1≤c≤10^9 2≤n≤2000,1≤m≤5000,1≤c≤109
1 ≤ u i , v i ≤ n , u i ≠ v i , 1 ≤ w i ≤ 100000 1≤u_i,v_i≤n, u_i≠v_i, 1≤w_i≤100000 1≤ui​,vi​≤n,ui​​=vi​,1≤wi​≤100000

分析：
如果若干条边能够构成环的话，B 就需要两次操作才能将这个环删除：一次操作取若干条边破坏环，第二次操作删掉剩余边。

接下来就想错了，就想着 A 要使得图中的环尽可能多，然后 B 的操作次数就是 环数 + 1，然后就想着如何选择能够构成环最多，想到缩点等等。。整个思路就偏了。

无论是一个环 还是 无数个环，B 只需要两次操作就能将所有边删掉：一次操作取所有环中的若干条边，破坏所有的环，第二次操作删除所有剩余边。
所以：只要有环，B 都只需要 2 次操作。
如果没有环，只有边，那么 B 只需要 1 次操作；
如果没有边，那么 B 需要 0 次操作。

所以，如果 A 所拥有的钱数能够购买一个环，就能使得 B 的操作次数为 2。
可以将所有边都先加到图中，判断图中价格最小的一个环的价格，看是否不超过 C。
也就是，求有向图的最小环。

那么就可以用有向图的三种实现方法。
但是，对于第一种实现方法，时间复杂度为 O(m*mlogn)，在这道题中会超时。
只能用第二种或者第三种实现方法。

实现二：

#include<bits/stdc++.h>
using namespace std;

#define Ios ios::sync_with_stdio(false),cin.tie(0)
#define mem(a,b) memset(a,b,sizeof a)
#define int long long
#define PII pair<int,int>
#define pb push_back
#define fi first
#define se second
#define endl '\n'

map<int,int> mp;

const int N = 200010, mod = 1e9+7;
int T, n, m, k;
int a[N], c;
int dist[N], f[N];
vector<PII> e[N];
int mina = 1e18;

void dij(int st)
{
	priority_queue<PII, vector<PII>, greater<PII> > que;
	que.push({0, st});
	for(int i=1;i<=n;i++) dist[i] = 1e9, f[i] = 0;
	dist[st] = 0;

	while(que.size())
	{
		int x = que.top().se;
		que.pop();
		
		if(f[x]) continue;
		f[x] = 1;
		
		for(auto it : e[x])
		{
			int tx = it.first, w = it.second;
			
			if(tx == st) mina = min(mina, dist[x] + w);
			
			if(dist[tx] > dist[x] + w)
				dist[tx] = dist[x] + w, que.push({dist[tx], tx});
		}
	}
}

signed main(){
	Ios;
	cin>>n>>m>>c;
	
	int ans = 0;
	for(int i=1;i<=m;i++)
	{
		int x, y, z;cin>>x>>y>>z;
		e[x].pb({y, z});
		
		if(z <= c) ans = 1;
	}
	
	for(int i=1;i<=n;i++) dij(i);
	if(mina <= c) ans = 2;
	
	cout << ans;
	
	return 0;
}

实现三：

#include<bits/stdc++.h>
using namespace std;

#define Ios ios::sync_with_stdio(false),cin.tie(0)
#define mem(a,b) memset(a,b,sizeof a)
#define int long long
#define PII pair<int,int>
#define pb push_back
#define fi first
#define se second
#define endl '\n'

map<int,int> mp;

const int N = 5010, mod = 1e9+7;
int T, n, m, k;
int a[N], c;
int dist[N][N], f[N];
vector<PII> e[N];

int dij(int st)
{
	priority_queue<PII, vector<PII>, greater<PII> > que;
	que.push({0, st});
	
	for(int i=1;i<=n;i++) dist[st][i] = 1e10, f[i] = 0;
	dist[st][st] = 0;
	
	while(que.size())
	{
		int x = que.top().se;
		que.pop();
		
		if(f[x]) continue;
		f[x] = 1;
		
		for(auto it : e[x])
		{
			int tx = it.fi, w = it.se;
			
			if(dist[st][tx] > dist[st][x] + w)
				dist[st][tx] = dist[st][x] + w, que.push({dist[st][tx], tx});
		}
	}
}

signed main(){
	Ios;
	cin>>n>>m>>c;
	
	int ans = 0;
	for(int i=1;i<=m;i++)
	{
		int x, y, z;cin>>x>>y>>z;
		e[x].pb({y, z});
		
		if(z <= c) ans = 1;
	}
	
	for(int i=1;i<=n;i++) dij(i);
	
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
		{
			if(i!=j && dist[i][j] + dist[j][i] <= c) ans = 2; 
		}
		
	cout << ans;
	
	return 0;
}

以前只知道 Floyd求最小环，没想到 dijkstra求最小环 的时间效率甚至更优。

如果哪里有问题的话欢迎留言讨论~

小酒窝.
关注
  • 8
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最小环(floyd以及dijkstra实现+例题）
darren0424的博客
09-04 1774
最小环定义 最小环是指在一个图中，有n个节点构成的边权和最小的环(n>=3)。 一般来说,最小环分为有向图最小环和无向图最小环。 最小环算法： 直接暴力： 设\(u\)和\(v\)之间有一条边长为\(w\)的边,\(dis(u,v)\)表示删除\(u\)和\(v\)之间的连边之后,\(u\)和\(v\)之间的最短路。那么最小环是\(dis(u,v)+w\)总时间复杂度\(O(n^2...
算法Dijkstra-Algorithm.zip
06-29
dijkstra算法 算法概述： 该算法是一个求最短路径的算法，具体算法的思想为： 找出离源点O最近的点，把该点设为S； 以S点为中转点，查看如果以S点为中转点，计算源点O中转S点到各点的距离transfer_distance； ...
有向图求最小环
Harris-H的博客
11-19 2543
文章目录有向图求最小环方法1floyd方法2dijkstra方法3tarjan方法4 拓扑排序方法5 并查集求环 有向图求最小环 方法1floyd 三重循环扫一遍，然后 rep(i,1,n){ if(d[i][i]==inf) continue; ans=min(ans,d[i][i]); } 时间复杂度：O(n3)O(n^3)O(n3) 方法2dijkstra 对每个结点dijkstradijkstradijkstra一次。 思想与floydfloydfloyd类似。 时间复杂度：O(n(n
最小环算法
cosx_的博客
11-29 2330
知乎学习链接 最小环概念： 在无向图中，最小环至少应当包含 333 个顶点。也就是说，将无向边拆分为两条有向边，以此形成的 222 顶点环，不能视作最小环，有向图则无顶点数的限制。 在图论中，一张图的最小环长度也被称为它的围长（girth）。 Floyd求无向图最小环 该算法最常使用，足以解决绝大多数无向图最小环问题。 当最外层恰好循环到 kkk 时，代表着目前所求出的最短路所含的点集为 [1,k)[1,k)[1,k)。 这时的中转点 kkk 一定不存在于 iii —> jjj 的最短路中，然后再枚举
图论最小环问题求解
My vegetable has exploded.
05-19 5838
图上最小环问题,Floyd非常好使.
求最小环
weixin_30786617的博客
08-15 288
floyd求最小环 2011-08-14 9:42 1 定义: 通常来说最小环是针对有向图而言 从一个点出发,经过一条简单路径回到起点成为环.图的最小环就是所有环中长度最小的. 2.怎样求最小环呢? 1传统的解决方法(dijkstra): 任意一个环的权值，我们都可以看成两个有边相连的结点i、j的直接距离加上i、j间不包含边(边i->j)的最短路...
dijkstra-matlab-master.zip_alg path_dijkstra
07-15
在`dijkstra-matlab-master`项目中，可能包含了以下文件和代码实现： 1. `dijkstra.m`: 主函数，实现Dijkstra算法。 2. `graph.m`: 图的表示和操作函数，如创建图、添加边、获取邻居等。 3. `priorityQueue.m`: ...
matlab-dijkstra-cycle.zip_dijkstra
07-15
matlab-dijkstra-代码，有需要的下载看看，共同学习
Dijkstra最短路径算法 - MATLAB.zip
最新发布
06-29
dijkstra算法
Dijkstra-the-shorest-path.rar_数据结构_C++_
08-12
《Dijkstra最短路径算法的C++实现》 在计算机科学中，数据结构与算法是构建高效软件的基础，其中Dijkstra算法是解决图论问题中的一个经典算法，它用于寻找图中两个节点间的最短路径。本文将深入探讨Dijkstra算法的...
最小环(有向无向均可)
Ciocio
09-28 1170
朴素的算法：     令e(u,v)表示u和v之间的连边，再令min(u,v)表示，删除u和v之间的连边之后，u和v之间的最短路。那么最小环则是min(u,v) + e(u,v)，时间复杂度是O(V^2E)。 改进的方法：     在floyd的同时，顺便算出最小环      ans=INF; for(int k=1;k<=N;k++) { for(int i=1
无向图的最小环问题 （Floyd算法）
.SAI.的博客
01-13 1858
问题描述： 题目传送门 解题思路：
有向图最小环问题
呆头呆脑没有烦恼
02-13 1732
有向图必须满足每一条边都是有向的，即若存在边x-&gt;y，就不能存在边y-&gt;x。这样的话，联想最短路，发现有向图如果一个点两次被遍历，那一定是成一环。并且，有向图最小环定义是不存在点数限制的，无向图之所以有约束，是避免把最短的一条边走两次。所以无向图只能使用floyd。这段文字是我刚才咨询了lyd之后，总结出来的。具体做法是，枚举每一个点，执行dijkstra算法，不同的是，处理完起点后，...
2021CCPC桂林 E. Buy and Delete（有向图的最小环）
HeartWine的博客
11-17 806
题目链接 题目大意： 有一个有向边集EEE，每个边有一个花费ppp，一开始有一个空图GGG，AliceAliceAlice有ccc元钱，现在她需要从边集EEE中选出来一些边添加到GGG中，且这些边的总花费不能超过ccc。BobBobBob需要对图GGG进行删边操作，每次BobBobBob可以从图GGG中选出一些边满足这些边是无法组成环的，然后从图中删除它们，直到GGG中没有边。现在AliceAliceAlice需要选出一些边使得BobBobBob的操作次数最多，BobBobBob删除边时会进行最优操作。输出
图论 最小环 Floyd
Authur_gyc
08-20 784
概念 最小环：指一个由n个点构成的图中，边权和最小的环。(n >= 3)。 最小环分为有向图最小环和无向图最小环。 这里讲一下 无向图最小环 方法 n为点的个数，m为边的条数。 三种解法： 一、暴力 时间复杂度O（n2 m） 暂时没学 二、Dijkstra 时间复杂度O（m(n+m)lognm(n + m)log nm(n+m)logn） 暂时没学 三、Floyd 时间复杂度O（n3） 设原...
【图论】环问题（最小环、最大环、环计数）
分享XCPC常用算法和相关技巧
05-03 3913
关于图论中环的一些常见问题，包括最小环、最大环、环计数
最小环的几种解法（并查集、删边）
qq_38993096的博客
02-23 2803
题目: https://www.luogu.org/problemnew/show/P2661 题解: 原理：如果有两个点祖先节点相同，那么就可以构成一个环，长度为两个点到祖先节点长度之和+1。 注意：图中不一定有一个环，即不一定是一个连通图，可能有好几个连通分量。 ...
2021桂林-Buy and Delete-(思维+distra求有向图最小环)
m0_52398496的博客
04-10 383
E 题意： 就是给你n个点m条边，然后每条边有一个价值，小A现在又c元钱，他可以买一些边，然后放进图中。然后小B每次可以删去一些边，这些边不能构成环。小A想让小B删的次数尽量多，小B会删边次数尽量少，问你小B最终会删多少边。 思考： 真的绝绝子啊这题，害，当时和于讨论出题意之后，立马想到了一个想法答案就是环的数量+1，为什么这样想呢，因为我想着每次对每条环删去一条边，然后剩下的图不能构成环了再一次删掉。现在就变成了找环的题目，我一看是有向图，可以直接缩点，按所有环的大小排序看看小A最多能拿多少环。 实际上题
图论：并查集求最小环
weixin_43827530的博客
12-02 4134
图论：并查集求最小环 概念： 图、路、环： 一个有向图由G=(N,A)表示，其中N表示节点集，A表示边集边(i,j)为一有序对，i为出发节点，j为终止节点。在无向图中(i,j)与(j,i)一致。 路是由节点及其对应的边依次相连构成。 环是出发节点和终止节点相同的路。 如果一条路不含重复边和重复节点，就被称做简单路，出发节点和终止节点相同的简单路就被称为简单环。 对于有向图而言 可以使用拓扑排序的方式找出图中的环 引入例题： P2661 信息传递 题目描述 有 nnn 个同学（编号为 111 到 nnn ）
Dijkstra算法求最小环 c++
05-07
Dijkstra算法是一种用于解决带权重图的单源最短路径问题的贪心算法。它通过维护一个顶点集合S来保证已求出的最短路径长度为当前所有未标记顶点中最小的那一个。Dijkstra算法求解的是从源点到图中其它各个顶点的最短路径问题，而不是求最小环问题。 对于求解最小环问题，可以使用Floyd算法或Bellman-Ford算法。下面是使用Floyd算法求解最小环的步骤： 1.初始化二维数组dist[i][j]，表示i到j的最短路径长度，如果i与j之间没有边相连，则dist[i][j]赋为INF（正无穷）。 2.初始化二维数组path[i][j]，表示i到j的最短路径上j的前一个顶点。 3.对于每个顶点k，遍历所有的(i,j)对，如果dist[i][j] > dist[i][k] + dist[k][j]，则更新dist[i][j]和path[i][j]的值。 4.遍历所有的(i,j)对，找出其中dist[i][j] + dist[j][i]最小的那一个，即为最小环。 这里需要注意的是，在实现过程中需要注意处理图中存在负权边和负权环的情况，以免导致算法出错。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值