旅行家的预算解析（贪心）很详细哦

问题描述
　　一个旅行家想驾驶汽车以最少的费用从一个城市到另一个城市（假设出发时油箱是空的）。给定两个城市之间的距离D1、汽车油箱的容量C（以升为单位）、每升汽油能行驶的距离D2、出发点每升汽油价格P和沿途油站数N（N可以为零），油站i离出发点的距离Di、每升汽油价格Pi（i=1，2，……N）。计算结果四舍五入至小数点后两位。如果无法到达目的地，则输出“No Solution”。
输入格式
　　第一行为4个实数D1、C、D2、P与一个非负整数N；
　　接下来N行，每行两个实数Di、Pi。
输出格式
　　如果可以到达目的地，输出一个实数（四舍五入至小数点后两位），表示最小费用；否则输出“No Solution”（不含引号）。
样例输入
275.6 11.9 27.4 2.8 2
102.0 2.9
220.0 2.2
样例输出
26.95

分析如下：

• 贪心的整体最优是用最少的油费到达终点。
• 贪心的局部最优解是优先到达油价更低的加油站，使低价格的油能行驶尽量长的距离。

具体实现过程
1.对加油站根据油价进行排序
2.对于已经有序的加油站数组选择一个可以到达的加油站。
3.如果没有下一个加油站，判断从当前点是否能直接到终点
如果不能输出“No Solution”
如果有下一个加油站，判断当前加油站是否比下一个加油站的价格便宜
如果是，要在当前站点加满油
如果不是，只要把油加到能够刚好到达下一个加油站就好了

代码

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        double length=s.nextDouble();       //总距离
        double contain=s.nextDouble();      //油箱容量
        double rpv=s.nextDouble();          //每升能行驶的距离
        double maxRun=rpv*contain;          //加满油能行驶的路程
        double currPrice=s.nextDouble();    //当前的油价
        double curr=0.0;                    //当前距离出发点的距离
        double cost=0.0;                    //花费的金额
        //剩余的油量
        double remain=0.0;                  //剩余的油量

        Oil[] stations=new Oil[s.nextInt()];
        for (int i = 0; i < stations.length; i++) {
            stations[i]=new Oil(s.nextDouble(),s.nextDouble());
        }
        Arrays.sort(stations);

        //注意  由于是贪心  只考虑局部最优    所以不用考虑起始点的油价很高 在到达下一个油价最低点时花费了太多钱的问题

        while (curr < length) {
            //寻找下一个最优加油站
            Oil nextStation=null;
            for (int i = 0; i <stations.length ; i++) {
                //必须向前走
                if (stations[i].distance > curr) {
                    //必须可达
                    if (stations[i].distance <= curr + maxRun) {
                        //因为已经对价格排过序了 因此第一个遍历到可达的一定是剩余加油站价格最少的 但不一定比当前便宜
                        nextStation=stations[i];
                        break;
                    }
                }
            }

            //如果下一个站点为空 判断是否已经能到达终点
            if (nextStation == null) {
                if (curr + maxRun >= length) {
                    cost+=( (length-curr)/rpv -remain )*currPrice;
                    System.out.printf("%.2f\n",cost);
                } else {
                    System.out.println("No Solution");
                }
                break;
            } else {
                //如果不为空 判断当前价格是否比下一个加油站便宜
                if (nextStation.price > currPrice) {
                    //判断当前加油站能否直接到达终点
                    if (curr + maxRun >= length) {
                        cost += ((length - curr) / rpv -remain ) * currPrice;
                        System.out.printf("%.2f\n", cost);
                        break;
                    }
                    //当前价格比下一个加油站便宜  去下一个加油站加满油
                    else {
                        cost += contain * currPrice;
                        remain=contain;
                        //到了下一个加油站
                        remain-=(nextStation.distance-curr)/rpv;
                        currPrice = nextStation.price;
                        curr = nextStation.distance;
                    }
                }
                //当前价格比下一个加油站贵  去下一个加油站不用加满油
                else {
                    //把油加到刚好能到达下一个加油站
                    cost += ((nextStation.distance - curr) / rpv -remain) * currPrice;
                    //到了下一个加油站
                    currPrice = nextStation.price;
                    curr = nextStation.distance;
                    remain=0;
                }
            }
        }

    }
}

class Oil implements Comparable<Oil> {
    double  price;      //油价
    double  distance;   //距离起点的距离

    public Oil(double distance, double price) {
        this.distance = distance;
        this.price = price;
    }

    @Override
    public int compareTo(Oil oil) {
        return Double.compare(price,oil.price);
    }
}