POJ1806 

Bellman-Ford算法的反向利用。

可以把初始兑换的货币看成源点，采用bellman-ford进行求解，若可以实现要求，则说明图中存在可以无限增大的环，这个可以通过bellman-ford算法判断环是否存在求出来，若在求解过程中发现已经兑换回原货币，并且钱比之前多，则可以直接退出算法。由于兑换过程中每种货币值必须为非负的，因此可以把所有初始路径长度设置为0，按照兑换方式对边进行松弛。

上代码：

import java.util.Arrays;
import java.util.Scanner;

/*
 * 题意 ： 就是套汇的问题，汇率Rab， 增加了一个手续费  Cab 。。。。。。。每次的结果是  (本金 - 手续费) * 汇率，
 * 而且一个人拥有的钱的类型是已知的，拥有的value 钱的个数也是已知的， 问你能不能增值。

当成 每个节点之间都可以来回的图，但是 来回的权值不一样，汇率和手续费不一样，分别保存a到b的和b到a的手续费和汇率
才能是关键，其实也是个水题。。。。。

输入 ：
3 2 1 20.0                         //钱种类个数  汇率的个数，拥有第几种钱， 拥有多少钱
1 2 1.00 1.00 1.00 1.00            //钱a， 钱b， rab， cab， rba， cba
2 3 1.10 1.00 1.10 1.00				//rab 为汇率	cab为汇率
 输出：
YES
 * 
 * 
 * */
public class POJ1806 {
    static int n; // 货币种数
    static int m; // 兑换点数量
    static int s; // 持有第 s种 货币
    static double v; // 持有s 货币的本金
    static Edge[] rate;
    static Edge[] commissino;
    static double[] value;
    public static final double EPS = 1E-8;// 10 的 -8 次方

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        s = sc.nextInt() - 1;// 减去 1 是因为在数组中第一个数的角标为 0
        v = sc.nextDouble();
        int a;
        int b;
        double rab;
        double cab;
        double rba;
        double cba;
        rate = new Edge[m * 2];
        commissino = new Edge[m * 2];
        value = new double[n];

        for (int i = 0; i < 2 * m; i++) {
            a = sc.nextInt() - 1;
            b = sc.nextInt() - 1;
            rab = sc.nextDouble();
            cab = sc.nextDouble();
            rba = sc.nextDouble();
            cba = sc.nextDouble();

            rate[i] = new Edge();
            rate[i].s = a;//这里是a
            rate[i].e = b;
            rate[i].v = rab;
            commissino[i] = new Edge();
            commissino[i].s = a;
            commissino[i].e = b;
            commissino[i].v = cab;

            i++;
            rate[i] = new Edge();
            rate[i].s = b;//跟上面的不一样哦  这里是b
            rate[i].e = a;//
            rate[i].v = rba;
            commissino[i] = new Edge();
            commissino[i].s = b;//
            commissino[i].e = a;//
            commissino[i].v = cba;
        }
        new POJ1806().solve();
    }

    public void solve() {
        if (bellman_ford(s, rate, commissino)) {
            System.out.println("YES");
        } else {
            System.out.println("NO");
        }
    }

    private static boolean bellman_ford(int ss, Edge[] rat, Edge[] com) {
        // TODO Auto-generated method stub
        Arrays.fill(value, 0);// 快速给value数组元素赋值 为0
        value[ss] = v;
        boolean released;
        while (value[ss] <= v + EPS) {
            released = false;
            for (int i = 0; i < 2 * m; i++) {
                if (value[rat[i].e] + EPS < (value[rat[i].s] - com[i].v) * rat[i].v) {//这里反向利用Bellman_Ford算法 来判断是否无限增大
                    value[rat[i].e] = (value[rat[i].s] - com[i].v) * rat[i].v;
                    released = true;
                    //System.out.println(Arrays.toString(value));
                }
            }
            if (!released) {
                //System.out.println(true);
                return value[ss] > v + EPS;
            }
        }
        //System.out.println(value[s]);
        return true;
    }

}

class Edge {
    int s;
    int e;
    double v;
}