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

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

题目大意：

    有多种汇币，汇币之间可以交换，这需要手续费，当你用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");
}