1033. To Fill or Not to Fill

【题意】
给出了两个城市之间加油站的位置和每单位量汽油的价格，求出到达目的地所需的最少油价，若到不了就返回能到达的最远距离。

【思路】
用贪心的思想去做，不过这题的贪心有点复杂，必须要好好静下心来分析才能找到规律。总结了一下大概可分下面几种情况（maxDist为加满油后车子能行驶的最远路程）：
1. 前方maxDist有终点
1.1. 油够用，直接走
1.2. 油不够，前方加油站里有油价更低的，将油加到能够走到最近的油价更低的加油站（若本来就够则不加）
1.3. 油不够，前方也没有油价更低的，在这个加油站加到恰能走到终点的油
2. 前方maxDist没有终点，有加油站
2.1. 前方加油站里有油价更低的，将油加到能够走到最近的油价更低的加油站（若本来就够则不加）
2.2. 前方没有油价更低的，在这个加油站加满油，走到前面价格最低的加油站
3. 前方maxDist没有终点，也没有加油站
3.1. 加满油，能走多远走多远

【注意点】
1. 起点可能没有加油站，此时最远距离是0（有人说要考虑起点终点在同一点上的情况，不过题目说了距离是正数所以不存在这种情况）；

2. 找到比当前加油站更便宜的下一个最近加油站后，到达该加油站有可能不用加油，换句话说到该加油站时可能还有油剩余

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

#define MAXIMUM 1000000.0

typedef struct{
float price;
int dist;
}station;

bool cmp(station s1, station s2){
return s1.dist<s2.dist;
}

int main(int argc, char const *argv[])
{
int Cmax,Dist,Davg,N;
vector<station> stations;
station tmp;

cin >> Cmax >> Dist >> Davg >> N;
for(int i=0; i<N; i++){
cin >> tmp.price >> tmp.dist;
stations.push_back(tmp);
}
sort(stations.begin(),stations.end(),cmp);

//起点没加油站
if(stations[0].dist>0){
cout << "The maximum travel distance = 0.00";
system("pause");
return 0;
}

float currCost = 0.0;
float currDist = 0.0;
float currCap = 0.0;
int maxDist = Cmax*Davg;
int index = 0;
bool flag = false;
/*
1.	前maxDist有终点
1.1.	油够用，直接走
1.2.	油不够，前方加油站里有油价更低的，将油加到能够走到最近的油价更低的加油站（若本来就够则不加）
1.3.	油不够，在这个加油站加到恰能走到终点的油
2.	前maxDist没有终点，有加油站
2.1.	前方加油站里有油价更低的，将油加到能够走到最近的油价更低的加油站（若本来就够则不加）
2.2.	前方没有油价更低的，在这个加油站加满油，走到前面价格最低的加油站
3.	前maxDist没有终点，也没有加油站
加满油，能走多远走多远
*/
while(1){
//1.
if(currDist+maxDist>=Dist){
//1.1.
if(currDist+currCap*Davg>=Dist){
flag = true;
break;
}
else{
int nearestIndex = N;
for(int i=index+1; i<N; i++){
if(stations[i].price<=stations[index].price){
nearestIndex = i;
break;
}
}
//1.2.
if(nearestIndex!=N){
if((stations[nearestIndex].dist-currDist)/Davg>currCap){
currCost += ((stations[nearestIndex].dist-currDist)/Davg-currCap)*stations[index].price;
currDist = stations[nearestIndex].dist;
currCap = 0;
}
else{
currCap -= (stations[nearestIndex].dist-currDist)/Davg;
currDist = stations[nearestIndex].dist;
}
index = nearestIndex;
continue;
}
//1.3.
else{
currCost += ((Dist-currDist)/Davg-currCap)*stations[index].price;
flag = true;
break;
}
}
}
//2.
else if(index<N-1 && currDist+maxDist>=stations[index+1].dist){
float min = MAXIMUM;
int nearestIndex = N,nextIndex;
for(int i=index+1; i<N && currDist+maxDist>=stations[i].dist; i++){
if(stations[i].price<min){
min = stations[i].price;
nextIndex = i;
}
if(stations[i].price<=stations[index].price && i<nearestIndex){
nearestIndex = i;
}
}
//2.1.
if(min<=stations[index].price){
if((stations[nearestIndex].dist-currDist)/Davg>currCap){
currCost += ((stations[nearestIndex].dist-currDist)/Davg-currCap)*stations[index].price;
currDist = stations[nearestIndex].dist;
currCap = 0;
}
else{
currCap -= (stations[nearestIndex].dist-currDist)/Davg;
currDist = stations[nearestIndex].dist;
}
index = nearestIndex;
continue;
}
//2.2.
else{
currCost += (Cmax-currCap)*stations[index].price;
currCap = Cmax-(stations[nextIndex].dist-currDist)/Davg;
currDist = stations[nextIndex].dist;
index = nextIndex;
continue;
}
}
//3.
else{
currDist = currDist+maxDist;
break;
}
}

if(flag){
printf("%.2f", currCost);
}
else{
printf("The maximum travel distance = %.2f", currDist);
}

system("pause");
return 0;
}