PAT 1033

JAVA没法玩耍系列，这道题限时10ms，所以我也不知道到底对不对，反正示例是正确的

贪心法，对于我来说很绕的贪心法。

分为下面的步骤

在满油情况下能够跑到的所有加油站中搜索

1. 如果该加油站比当前加油站要便宜，则加油到刚好跑到这个加油站，继续下一轮

2. 如果到了终点，则加油到终点，用哨兵保证这一点

3. 如果在这段区间，没有找到比当前加油站更便宜的加油站，则加油到满油

其实就是顺序没处理好所以做了很长时间，原来的做法是依次向后找到最便宜的加油站，如果超过最大距离了又怎么样，这就不如限定在一个范围内找加油站了

感觉学到了一些，要把通用情况放到最外面判断。

代码如下：

import java.util.*;
import java.io.*;

class FastReader{
    BufferedReader reader;
    StringTokenizer tokenizer;
    
    public FastReader(InputStream stream){
        reader = new BufferedReader(new InputStreamReader(stream), 1 << 22);
        tokenizer = null;
    }
    
    public String next(){
        while (tokenizer == null || !tokenizer.hasMoreTokens()){
            try { 
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (Exception e){
                //System.out.println(-1);
                throw new RuntimeException(e);
            }
        }
        
        return tokenizer.nextToken();
    }
    
    public int next_int(){
        return Integer.parseInt(next());
    }
    
    public float next_float(){
        return Float.parseFloat(next());
    }
}

class StationInfo{
    float dist;
    float price;
}

public class Main {
    public static void main(String[] args){
        FastReader reader = new FastReader(System.in);
        float cap, dist, avg_dist;
        int num;
        
        cap = reader.next_float();
        dist = reader.next_float();
        avg_dist = reader.next_float();
        num = reader.next_int();
        
        float longest_run = avg_dist * cap;
        StationInfo[] stations = new StationInfo[num + 1];
        for (int i = 0; i < num; i++){
            stations[i] = new StationInfo();
            stations[i].price = reader.next_float();
            stations[i].dist = reader.next_int();
        }
        stations[num] = new StationInfo();
        stations[num].dist = dist;
        stations[num].price = 0;
        
        Arrays.sort(stations, new Comparator<StationInfo>(){
            public int compare(StationInfo s1, StationInfo s2){
                return (s1.dist - s2.dist < 0.0f) ? -1 : 1;
            }
        });
        
        for (int i = 0; i < stations.length - 1; i++){
            if (stations[i + 1].dist - stations[i].dist > longest_run){
                float max_travel = stations[i].dist + longest_run;
                System.out.println(String.format("The maximum travel distance = %.2f", max_travel));
                return;
            }
        }
        
        if (stations[0].dist != 0.0f)
            System.out.println(String.format("The maximum travel distance = %.2f", 0.0f));
        
        int cur_station = 0;
        float cur_oil = 0.0f;
        float cost_sum = 0.0f;
        while (cur_station < num){
            float cur_run = 0.0f;
            int next_station = cur_station;
            int lowest_price_station = cur_station;
            float lowest_price = Float.MAX_VALUE;
            boolean solved = false;
            while (true){
                float cur_dist = stations[next_station + 1].dist - stations[next_station].dist;
                if (cur_dist + cur_run > longest_run)
                    break;
                cur_run += cur_dist;
                next_station++;
                
                if (stations[next_station].price < stations[cur_station].price){
                    float need_oil = cur_run / avg_dist;
                    float add_oil = (cur_oil > need_oil) ? 0.0f : (need_oil - cur_oil);
                    cost_sum += add_oil * stations[cur_station].price;
                    
                    cur_oil = cur_oil + add_oil - need_oil;
                    cur_station = next_station;
                    
                    solved = true;
                    break;
                }
                
                /*
                if (next_station != cur_station){
                    if (stations[next_station].price < lowest_price){
                        lowest_price_station = next_station;
                        lowest_price = stations[next_station].price;
                    }
                }
                */
            }
            
            if (!solved){
                float add_oil = cap - cur_oil;
                cost_sum += add_oil * stations[cur_station].price;
                cur_oil += add_oil;
                cur_oil -= cur_run / avg_dist;
                cur_station = next_station;
            }
        }
        
        System.out.println(String.format("%.2f", cost_sum));
    }
}