加油站问题【贪心】

题目描述

有了高速公路，开车从杭州到任何其他城市都很容易。但由于汽车的油箱容量有限，我们必须不时地在路上找到加油站。不同的加油站可能会给出不同的价格。你被要求仔细设计最便宜的路线去。

输入描述:

对于每个测试实例

第一行包含4个正数：Cmax（<=100），即油箱的最大容量；D（<=30000），即杭州到目的地城市的距离；Davg（<=20），即汽车每单位汽油可行驶的平均距离；N（<=500），即加油站总数。

接下来是N行，每行包含一对非负数：Pi，煤气单价，Di（<=D），这个站到杭州的距离，i=1，…N。一行中的所有数字用空格隔开。

输出描述:

对于每个测试用例，一行打印最便宜的价格，精确到小数点后2位。假设开始时油箱是空的。如果无法到达目的地，请打印“最大行驶距离=X”，其中X是车辆可以行驶的最大可能距离，精确到小数点后2位。

示例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
50 1300 12 2
7.10 0
7.00 600

输出

749.17
The maximum travel distance = 1200.00

思路一：

采用贪心的做法，情况如下：

先对输入的加油站进行距离升序排序（如果距离相同，按照价格从小到大，因为距离相同的油站我们取最便宜的）。

1.刚开始，车没油，所以要找0距离油价最少的那一个,如果起始点没有油站，那么车无法走，直接认为无解

2.然后考察车的最大距离(Cmax*Davg)里的所有加油站，看看是否有比当前油价便宜的加油站

 ①.若有，此时若剩余油够到达，则不用加油，否则，只需把油加到正好可到达该加油站（遇到的第一个油价更便宜的加油站）即可，因为之后的距离我想用便宜的油价。

 ②.若没有，我们只能在最大距离内找到当前油价最小的那一个加油站（此时邮价仍是比上次贵的）即可，但是此时我们要把油加满（因为当前油价便宜！），加满之后，到指定加油站之后继续进行考察：再次根据距离，补充油（注意此时油箱是有油的，上次油价便宜）。

注意: 若在最大距离内一个车站都找不到，则结束了，break，输出已走的最大距离。

代码:

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

struct GasStation{
    double Pi;
    double Di;
    bool operator < (const GasStation &a) const{
        if(Di==a.Di)
            return Pi<a.Pi;
        else
            return Di<a.Di;
    }
};

int main()
{
    int Cmax,D,Davg,N;
    GasStation station[501];
    while(cin>>Cmax>>D>>Davg>>N)
    {
        
        for(int i=0;i<N;i++)
        {
            cin>>station[i].Pi>>station[i].Di;
        }
        station[N].Di=D;
        station[N].Pi=0.0;
        sort(station,station+N+1);
        if(station[0].Di!=0)
        {
            cout<<"The maximum travel distance = 0.00"<<endl;
            continue;
        }
        GasStation Current_station;
        Current_station=station[0];
        int Dmax=Cmax*Davg;
        double p=0.00;
        double c=0.00;
        double d_space;
        int j=0;
        bool ifstation;
        bool ischeap;
        while(Current_station.Di!=D)
        {
            ischeap=false;
            ifstation=false;
            double min_p=100000.0;
            for(int i=j+1;i<=N;i++)
            {
              if(station[i].Di<=Current_station.Di+Dmax)
              { 
                ifstation=true;
                
                if(station[i].Pi<Current_station.Pi)
                {
                    ischeap=true;
                    j=i;
                    d_space=station[i].Di-Current_station.Di;
                    if(c>=(d_space/(Davg*1.0))) //这里乘个1.0是为了把Davg变成double类型
                    {
                        c-=(d_space/(Davg*1.0));
                    }
                    else{
                        p+=((d_space/(Davg*1.0))-c)*Current_station.Pi;
                        c=0.0;
                    }
                    Current_station=station[i];
                    break;
                }
                else 
                {
                    if(station[i].Pi<min_p)
                    {
                        j=i;
                        min_p=station[i].Pi;
                    }
                    
                }
              }
            }
            if(!ifstation)
            {
                printf("The maximum travel distance = %.2lf\n",Current_station.Di+Dmax);
                break;
            }
            if(!ischeap)
            {
                d_space=station[j].Di-Current_station.Di;
                p+=(Cmax-c)*Current_station.Pi;
                c=Cmax-(d_space/(Davg*1.0));
                Current_station=station[j];
            }
        }
        if(ifstation)
           printf("%.2lf\n",p);
    }
    return 0;
}

思路二（非常巧妙）：

【原理：对结果进行倒推】

【代码来源：牛客网用户"uever"】

对输入的加油站进行油价升序排序。

利用贪心策略,从最便宜的加油站开始,每个加油站加的油最多能走cmax*davg路程。利用一个30000大小的flag数组记录是否有重合区域

代码：

/*
核心思路:利用贪心策略,从最便宜的加油站开始,每个加油站加的油最多能走cmax*davg路程.
利用一个30000大小的flag数组记录是否有重合区域
*/
#include<cstdio>
#include<algorithm>
using namespace std;

struct sta{
    double pi;
    int di;
    bool operator < (const sta& b) const{
        return pi<b.pi;
    }
}a[501];

int main(){
    int cmax, d, davg, n;
    double sum;
    while(scanf("%d %d %d %d", &cmax, &d, &davg, &n)!=EOF){
        for(int i=0; i<n; i++) scanf("%lf %d", &a[i].pi, &a[i].di);
        sort(a, a+n);
        //
        sum = 0;//记录花费
        int flag[30001]={0}, max = cmax*davg, tmp, cnt;
        for(int i=0; i<n; i++){
            tmp = (a[i].di+max<d?max:d-a[i].di);    //如果到终点距离<max,只需加上足够走到终点的油
            cnt = 0;    //记录有多长距离需要该加油站的油
            for(int j=a[i].di; j<a[i].di+tmp; j++){
                if(flag[j]==0){
                    flag[j] = 1;
                    cnt++;
                }
            }
            sum += cnt/(davg*1.0)*a[i].pi;    //加上在该加油站的花销
        }
        //check
        int i;
        for(i=0; i<d; i++){
            //有的路程没有被覆盖到说明走不到这里
            if(flag[i]==0){
                printf("The maximum travel distance = %.2lf\n", (double)i);
                break;
            }
        }
        if(i==d){
            printf("%.2lf\n",sum);
        }
    }
    return 0;
}