kuangbin 专题四 E 题 （正权回路）Currency Exchange（POJ1860）

我们的城市有几个货币兑换点。让我们假设每一个点都只能兑换专门的两种货币。可以有几个点，专门从事相同货币兑换。每个点都有自己的汇率，外汇汇率的A到B是B的数量你1A。同时各交换点有一些佣金，你要为你的交换操作的总和。在来源货币中总是收取佣金。

例如，如果你想换100美元到俄罗斯卢布兑换点，那里的汇率是29.75，而佣金是0.39，你会得到（100 - 0.39）×29.75＝2963.3975卢布。

你肯定知道在我们的城市里你可以处理不同的货币。让每一种货币都用唯一的一个小于N的整数表示。然后每个交换点，可以用6个整数表描述：整数a和b表示两种货币，a到b的汇率，a到b的佣金，b到a的汇率，b到a的佣金。

nick有一些钱在货币S，他希望能通过一些操作（在不同的兑换点兑换），增加他的资本。当然，他想在最后手中的钱仍然是S。帮他解答这个难题，看他能不能完成这个愿望。

 

输入数据：

第一行四个数，N，表示货币的总数；M，兑换点的数目；S，nick手上的钱的类型；V，nick手上的钱的数目；1<=S<=N<=100, 1<=M<=100, V 是一个实数 0<=V<=10³. 

接下来M行，每行六个数，整数a和b表示两种货币，a到b的汇率，a到b的佣金，b到a的汇率，b到a的佣金（0<=佣金<=10²，10^-2<=汇率<=10²）

 

输出数据：

如果nick能够实现他的愿望，则输出YES，否则输出NO。

 

样例输入：

3 2 1 20.0

1 2 1.00 1.00 1.00 1.00

2 3 1.10 1.00 1.10 1.00

 

样例输出

YES

思路：（引用）

有多种汇币，汇币之间可以交换，这需要手续费，当你用100A币
交换B币时，A到B的汇率是29.75，手续费是0.39，那么你可以得到
(100 - 0.39) * 29.75 = 2963.3975 B币。问s币的金额经过交换最终
得到的s币金额数能否增加
货币的交换是可以重复多次的，所以我们需要找出是否存在
正权回路，且最后得到的s金额是增加的
怎么找正权回路呢？（正权回路：在这一回路上，顶点的权值能不断增加即能一直进行松弛）

关键在于反向利用Bellman-Ford算法


单源最短路径算法，因为题目可能存在负边，所以用Bellman Ford算法，
原始Bellman Ford可以用来求负环，这题需要改进一下用来求正环

一种货币就是图上的一个点
一个“兑换点”就是图上两种货币之间的一个兑换环，相当于“兑换方式”M的个数，是双边
唯一值得注意的是权值，当拥有货币A的数量为V时，A到A的权值为K，即没有兑换
而A到B的权值为(V-Cab)*Rab
本题是“求最大路径”，之所以被归类为“求最小路径”是因为本题题恰恰
与bellman-Ford算法的松弛条件相反，求的是能无限松弛的最大正权路径，
但是依然能够利用bellman-Ford的思想去解题。
因此初始化d(S)=V   而源点到其他店的距离（权值）初始化为无穷小（0），
当s到其他某点的距离能不断变大时，说明存在最大路径

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std ;

#define maxn 210 
double dis[maxn] ;

int total ; // 边得总数量 
int D[maxn][2] ; // 存放 边的起点和终点
double Cast[maxn][2] ; // 存放汇率和手续费
// bellman_ford 求正环 
bool bellman_ford(int s , int n , double V) {
    for(int i=1 ; i<=n ; i++){
        dis[i] = 0 ; 
    } 
    dis[s] = V ; 
    for(int i=1 ; i<= n-1 ; i++){//循环 n-1 次 
        bool flag = false ; //优化 
        for (int j=0 ; j<total ; j++){
            int u = D[j][0] ; 
            int v = D[j][1] ; 
            if(dis[v] < (dis[u] - Cast[j][1])*Cast[j][0]){//求最大 
                dis[v] = (dis[u] - Cast[j][1])*Cast[j][0] ; 
                flag = true ; 
            }
        }
        if(!flag) return false ; //没有更新 ， 不存在正环 
    }
    for(int j=0 ; j<total ; j++){
        if(dis[D[j][1]] < (dis[D[j][0]] - Cast[j][1])*Cast[j][0]){
            return true ; // 存在正环 
        }
    }
    return false ;  
}

int main() {
    int n , m ;
    int a , b ;
    double c , d , e , f ;

    int s ;
    double v ;
    while(~scanf("%d%d%d%lf" ,&n , &m , &s , &v )) {
        total = 0 ;
        while(m--) {
            scanf("%d%d%lf%lf%lf%lf" , &a , &b , &c , &d , &e , &f);
            D[total][0] = a ;
            D[total][1] = b ;
            Cast[total][0] = c ;
            Cast[total][1] = d ;
            total ++ ;
            D[total][0] = b ;
            D[total][1] = a ;
            Cast[total][0] = e ;
            Cast[total][1] = f ;
            total ++ ;
        }
        if(bellman_ford(s,n,v))
            printf("YES\n") ; 
        else printf("NO\n") ; 
    }
    return 0 ;  
}

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
using namespace std;
int n,m,s;
double map[105]= {0},g1[105][105]= {0},g2[101][101]= {0},v;
int floyd() {
    int i,j,k;
    double d[105];
    for(i=1; i<=n; i++)d[i]=map[i];
    for(k=1; k<=n; k++)
        for(i=1; i<=n; i++)
            for(j=1; j<=n; j++)
                if((map[i]-g2[i][j])*g1[i][j]>map[j])map[j]=(map[i]-g2[i][j])*g1[i][j];
    for(i=1; i<=n; i++)
        if(d[i]<map[i])return 1;
    return 0;
}
int main() {
    cin>>n>>m>>s>>v;
    int i,j,k;
    for(i=1; i<=m; i++) {
        int a,b;
        double c,d,e,f;
        cin>>a>>b>>c>>d>>e>>f;
        g1[a][b]=c,g2[a][b]=d;
        g1[b][a]=e,g2[b][a]=f;
    }
    map[s]=v;
    floyd();
    if(floyd())cout<<"YES\n";
    else cout<<"NO\n";

}