zoukankan      html  css  js  c++  java
  • 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<=103

    接下来M行,每行六个数,整数a和b表示两种货币,a到b的汇率,a到b的佣金,b到a的汇率,b到a的佣金(0<=佣金<=102,10-2<=汇率<=102

    输出数据:

    如果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
    ") ; 
            else printf("NO
    ") ; 
        }
        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
    ";
        else cout<<"NO
    ";
    
    }
  • 相关阅读:
    基本排序算法分析
    Linux内核浅谈
    Linux内核浅谈
    Linux内核浅谈
    淘宝架构技术的演变
    淘宝架构技术的演变
    淘宝架构技术的演变
    中间件小结
    中间件小结
    中间件小结
  • 原文地址:https://www.cnblogs.com/yi-ye-zhi-qiu/p/7616541.html
Copyright © 2011-2022 走看看