POJ-1860___Currency Exchange —— 最短路判断正环

最新推荐文章于 2021-08-18 01:01:11 发布

Scar_Halo

最新推荐文章于 2021-08-18 01:01:11 发布

阅读量362

点赞数 1

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/Scar_Halo/article/details/83352861

ACM - SPFA 专栏收录该内容

6 篇文章

订阅专栏

本文探讨了在涉及多种货币的汇率交换场景中，如何通过Bellman-Ford算法和SPFA算法判断是否存在使得起始货币金额能通过一系列交换后增加的正环。详细介绍了两种算法的实现方式及代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目链接：点我啊╭(╯^╰)╮

题目大意：

有多种汇币，汇币之间可以交换，这需要手续费，当你用100A币交换B币时，A到B的汇率是29.75，手续费是0.39，那么你可以得到(100 - 0.39) * 29.75 = 2963.3975 B币。问s币的金额经过交换最终得到的s币金额数能否增加

解题思路：

判断正环，这里可以用Bellman-Ford，也能用spfa，这里给出一种类似Bellman-Ford算法的算法，和正确的spfa算法

代码思路：

感觉像是floyd，但感觉又不是，看出来的人麻烦和我说下。。注意用spfa的时候不需要判断入队次数，只需要判断起点的更新状态能否大于初始状态即可

核心：正负权回路的判断

Bellman-Ford：

include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int n, m, st;
double v, ori[105], re[105], k1[105][105], k2[105][105];

bool floyed() {
	for(int k=0; k<n; k++)                                 //插入k点
		for(int i=0; i<n; i++)
			for(int j=0; j<n; j++)
				re[j]= max(re[j], (re[i] - k2[i][j]) * k1[i][j]);
	for(int i=0; i<n; i++) 
		ori[i] = re[i];
	
	for(int k=0; k<n; k++)                                 //插入k点
		for(int i=0; i<n; i++)
			for(int j=0; j<n; j++)
				re[j]= max(re[j], (re[i] - k2[i][j]) * k1[i][j]);
	
	for(int i=0; i<n; i++)
		if(re[i]>ori[i]) 
			return true;
	return false;
}

void init() {
	scanf("%d%d%d%lf", &n, &m, &st, &v);
	re[st-1] = v;
	int x, y;
	double a, b, c, d;
	for(int i=0; i<m; i++) {
		scanf("%d %d %lf %lf %lf %lf", &x, &y, &a, &b, &c, &d);
		k1[x-1][y-1] = a; k2[x-1][y-1] = b;
		k1[y-1][x-1] = c; k2[y-1][x-1] = d;
	}
}

int main() {
	init();
	if(floyed()) puts("YES");
	else puts("NO");
}

SPFA：

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

const int MAXN = 200010;
const int MAXM = 500010;

struct EDGE {
	int next;
	int to;
	double k1, k2;
};
EDGE edge[MAXM];

int n, m, st, cnt;
double v, dis[MAXN];
int head[MAXN], num[MAXN];
bool vis[MAXN];
queue<int> Q;

void Add(int u, int v, double k1, double k2) {
	edge[++cnt].next = head[u];
	edge[cnt].to = v;
	edge[cnt].k1 = k1;
	edge[cnt].k2 = k2;
	head[u] = cnt;
}

void read() {
	int x, y;
	double a, b, c, d;
	scanf("%d%d%d%lf", &n, &m, &st, &v);
	for(int i=1; i<=m; i++) {
		scanf("%d%d%lf%lf%lf%lf", &x, &y, &a, &b, &c, &d);
		Add(x, y, a, b);Add(y, x, c, d);
	}
}

bool SPFA(int x) {
	while(!Q.empty()) Q.pop();
	cnt = 0;
	dis[x] = v;
	num[x] = 1;
	Q.push(x);
	vis[x] = true;
	while(!Q.empty()) {
		int k = Q.front();
		Q.pop();
		vis[k] = false;
		for(int i=head[k]; i!=0; i=edge[i].next) {
			int j = edge[i].to;
			double k1 = edge[i].k1;
			double k2 = edge[i].k2;
			if(dis[j] < (dis[k]-k2)*k1) {
				dis[j] = (dis[k]-k2)*k1;
				num[j] = num[k]+1;
				//if(num[j]>n) return 1;	//判断负环
				if(!vis[j]) {
					Q.push(j);
					vis[j] = true;
				}
			}
			if(dis[x]>v) return 1;
		}
	}
	return 0;
}

int main() {
	memset(vis, 0, sizeof(vis));
	memset(num, 0, sizeof(num));
	memset(head, 0, sizeof(head));
	read();
	SPFA(st) ? printf("YES\n") : printf("NO\n");
}