2021桂林-Buy and Delete-(思维+distra求有向图最小环)

72 篇文章 1 订阅
54 篇文章 2 订阅

E

题意:
就是给你n个点m条边,然后每条边有一个价值,小A现在又c元钱,他可以买一些边,然后放进图中。然后小B每次可以删去一些边,这些边不能构成环。小A想让小B删的次数尽量多,小B会删边次数尽量少,问你小B最终会删多少边。

思考:
真的绝绝子啊这题,害,当时和于讨论出题意之后,立马想到了一个想法答案就是环的数量+1,为什么这样想呢,因为我想着每次对每条环删去一条边,然后剩下的图不能构成环了再一次删掉。现在就变成了找环的题目,我一看是有向图,可以直接缩点,按所有环的大小排序看看小A最多能拿多少环。
实际上题意是对的,但是思路错了,想的太急了,陷入缩点里面去了。实际上就是第一次先把是环的地方都拿走一条边,这样就没有环了,然后再把剩下的一次性删去。也就是答案要么是0要么是1要么是2。所以就看看最小的环的权值是多少,怎么求呢?dfs不行,最传统的就是用distra求出来。有2种方法,一种是对于每个点跑一次distra,复杂度nmlog(n),这样找环的话就是两重循环点,dist[i][j]+dist[j][i]就是一个环的大小。还有一种是删去每一条边(a,b,w)然后从b跑distra,求出来b->a的最短距离dis,那么环的大小就是w+dis,复杂度是mmlog(n)。这个题目n是2000,m是5000,所以用第二种会超时,所以用第一种。

代码:

枚举点找环:

#include<bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define db double
#define int long long
#define PII pair<int,int >
#define mem(a,b) memset(a,b,sizeof(a))
#define IOS std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
		
using namespace std;
const int mod = 1e9+7,inf = 1e18;
const int N = 2e5+10,M = 2010;

int T,n,m,k;
int va[N];
int dist[M][M],vis[N];

vector<PII > e[N];

void distra(int A)
{
	for(int i=1;i<=n;i++) dist[A][i] = inf,vis[i] = 0;
	priority_queue<PII,vector<PII>,greater<PII> > q;
	q.push({0,A});
	dist[A][A] = 0;
	while(q.size())
	{ 
		auto t = q.top();
		q.pop();
		int now = t.se,dis = t.fi;
		if(vis[now]) continue;
		vis[now] = 1;
		for(auto tt:e[now])
		{
			int spot = tt.fi,w = tt.se;
			if(dist[A][spot]>dist[A][now]+w)
			{
				dist[A][spot] = dist[A][now]+w;
				q.push({dist[A][spot],spot});
			}
		}
	}
}

signed main()
{
	IOS;
	cin>>n>>m>>k;
	int ans = 0;
	for(int i=1;i<=m;i++)
	{
		int a,b,c;
		cin>>a>>b>>c;
		e[a].pb({b,c});
		if(c<=k) ans = 1;
	}
	for(int i=1;i<=n;i++) distra(i);
	for(int i=1;i<=n;i++)
	{
		for(int j=i+1;j<=n;j++)
		{
			if(dist[i][j]+dist[j][i]<=k)
			ans = 2;
		}
	}
	cout<<ans;
	return 0;
}

删边找环:
struct Node{
	int a,b,c;
}node[N];

int T,n,m,k;
int va[N];
int dist[N],vis[N];

vector<PII > e[N];

void distra(int st,int ed)
{
	for(int i=1;i<=n;i++) dist[i] = inf,vis[i] = 0;
	priority_queue<PII,vector<PII>,greater<PII> > q;
	q.push({0,ed});
	dist[ed] = 0;
	while(q.size())
	{ 
		auto t = q.top();
		q.pop();
		int now = t.se,dis = t.fi;
		if(vis[now]) continue;
		vis[now] = 1;
		for(auto tt:e[now])
		{
			int spot = tt.fi,w = tt.se;
			if(dist[spot]>dist[now]+w)
			{
				dist[spot] = dist[now]+w;
				q.push({dist[spot],spot});
			}
		}
	}
}

signed main()
{
	IOS;
	cin>>n>>m>>k;
	int ans = 0;
	for(int i=1;i<=m;i++)
	{
		int a,b,c;
		cin>>a>>b>>c;
		e[a].pb({b,c});
		if(c<=k) ans = 1;
		node[i] = {a,b,c};
	}
	for(int i=1;i<=m;i++)
	{
		int a = node[i].a,b = node[i].b,c = node[i].c;
		distra(a,b);
		if(dist[a]+c<=k) ans = 2;
	}
	cout<<ans;
	return 0;
}

总结:
多多思考啊,别tm陷进去了,当思路打不开的时候,一定是题意或者思路镐错了。

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
DFS (Depth-First Search) 和 BFS (Breadth-First Search) 是两种常见的遍历算法,而 Dijkstra 算法是一种单源最短路径算法。 DFS 从一个起始点开始,尽可能深入中的某个分支,直到不能再深入为止,然后回溯并探索另一个分支。这种算法通常通过递归实现。DFS 的缺点是可能陷入无限循,因为它不记录已经访问过的节点。 BFS 从一个起始点开始,首先将其所有邻居节点都遍历一遍,然后再遍历邻居节点的邻居节点,以此类推。BFS 通常使用队列实现,因为它涉及到按顺序处理节点。BFS 的优点是可以找到最短路径,但是缺点是需要存储所有已访问的节点,因此在空间上可能会比 DFS 更消耗内存。 Dijkstra 算法用于计算从一个节点到其他所有节点的最短路径。它依赖于每个节点到源节点的距离,以及从源节点到每个节点的边的权重。Dijkstra 算法使用一个优先队列来选择下一个节点,该队列按照距离排序,距离越短的节点越先被处理。Dijkstra 算法的缺点是不能处理负权重边,因为它的贪心策略假设边的权重都是非负数。 Distra 算法是一种改进的 Dijkstra 算法,它可以处理负权重边。它使用一个优先队列来选择下一个节点,但是与 Dijkstra 算法不同的是,Distra 算法在队列中添加了每个节点的估计距离和当前最短路径估计。这种算法的优点是可以处理负权重边,但是缺点是可能会陷入无限循

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值