1033 To Fill or Not to Fill java

With highways available, driving a car from Hangzhou to any other city is easy. But since the tank capacity of a car is limited, we have to find gas stations on the way from time to time. Different gas station may give different price. You are asked to carefully design the cheapest route to go.

Input Specification:

Each input file contains one test case. For each case, the first line contains 4 positive numbers: C​max​​ (≤ 100), the maximum capacity of the tank; D (≤30000), the distance between Hangzhou and the destination city; D​avg​​ (≤20), the average distance per unit gas that the car can run; and N (≤ 500), the total number of gas stations. Then N lines follow, each contains a pair of non-negative numbers: P​i​​, the unit gas price, and D​i​​ (≤D), the distance between this station and Hangzhou, for i=1,⋯,N. All the numbers in a line are separated by a space.

Output Specification:

For each test case, print the cheapest price in a line, accurate up to 2 decimal places. It is assumed that the tank is empty at the beginning. If it is impossible to reach the destination, print The maximum travel distance = X where X is the maximum possible distance the car can run, accurate up to 2 decimal places.

Sample Input 1:

50 1300 12 8
6.00 1250
7.00 600
7.00 150
7.10 0
7.20 200
7.50 400
7.30 1000
6.85 300

Sample Output 1:

749.17

Sample Input 2:

50 1300 12 2
7.10 0
7.00 600

Sample Output 2:

The maximum travel distance = 1200.00

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Main {
    /**
     * 假设当前处于的加油站编号为now，
     * 1，寻找距离当前加油站最近的油价低于当前油价的加油站k，加的油量恰好能到达加油站k
     * 2，如果找不到油价低于当前油价的加油站，则寻找油价最低的加油站，在当前加油站加满油，
     * 然后到加油站k
     * 3，如果到达不了任何一个加油站，那就不能到达
     * */

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] inputString = br.readLine().split("\\s+");
        double containerMax = Double.parseDouble(inputString[0]),
                distance = Double.parseDouble(inputString[1]),
                distanceAvg = Double.parseDouble(inputString[2]),
                sum = 0;
        int n = Integer.parseInt(inputString[3]);
        List<GasStation> gasStations = new ArrayList<>();
        for (int i=0; i<n; ++i) {
            String[] stationMessages = br.readLine().split("\\s+");
            GasStation temp = new GasStation();
            temp.gasPrice = Double.parseDouble(stationMessages[0]);
            temp.distance = Double.parseDouble(stationMessages[1]);
            gasStations.add(temp);
        }
        GasStation lastStation = new GasStation();
        lastStation.gasPrice = 0;
        lastStation.distance = distance;
        gasStations.add(lastStation);
        Collections.sort(gasStations, new GasStationComparator());
        if (gasStations.get(0).distance!=0) {
            System.out.println("The maximum travel distance = 0.00");
        } else {

            double maxDistance = containerMax*distanceAvg, nowGas = 0;
            int k = -1, nowStation=0;
            while(nowStation<n) {

                // 记录应该选中的加油站的坐标
                k = -1;
                double priceMin = Double.POSITIVE_INFINITY;
                for (int j=nowStation+1; gasStations.get(j).distance<=
                        gasStations.get(nowStation).distance+maxDistance&&j<=n; ++j) {
                    if (gasStations.get(j).gasPrice<priceMin) {
                        // 找出这一路单价最小的油站
                        k = j;
                        priceMin = gasStations.get(j).gasPrice;
                        if (priceMin<gasStations.get(nowStation).gasPrice) {
                            // 如果找到第一个油价低于当前油价时，直接跳出循环
                            break;
                        }
                    }
                }

                if (k==-1) {
                    // 说明不能到达目的地
                    break;
                } else {
                    // 如果找到了加油站，计算需要多少油能到达k站
                    double needGas = (gasStations.get(k).distance -
                            gasStations.get(nowStation).distance)/distanceAvg;
                    if (priceMin<gasStations.get(nowStation).gasPrice) {
                        // 如果加油站k的油价低于当前油价，那就加的油刚刚到这个加油站就行了
                        if (nowGas<needGas) {
                            // 当前油量跑不到k
                            sum += (needGas-nowGas)*gasStations.get(nowStation).gasPrice;
                            nowGas = 0;
                        } else {
                            // 当前油量能跑到k
                            nowGas -= needGas;
                        }
                    } else {
                        // 如果当前加油站的油价小于加油站k，那就在当前加油站加满跑过去
                        sum += (containerMax-nowGas)*gasStations.get(nowStation).gasPrice;
                        // 到达k加油站是，还剩多少油
                        nowGas = containerMax - needGas;

                    }
                    nowStation = k;
                }


            }
            if (nowStation==n) {
                // 说明到达了终点
                System.out.printf("%.2f\n", sum);
            } else {
                System.out.printf("The maximum travel distance = %.2f\n",
                        gasStations.get(nowStation).distance+maxDistance);
            }

        }

    }
}
class GasStationComparator implements Comparator<GasStation>{

    @Override
    public int compare(GasStation o1, GasStation o2) {
        return o1.distance.compareTo(o2.distance);
    }
}

class GasStation{
    double gasPrice;
    Double distance;

    @Override
    public String toString() {
        return "GasStation{" +
                "gasPrice=" + gasPrice +
                ", distance=" + distance +
                '}';
    }
}