题目

汽车从起点出发驶向目的地，该目的地位于出发位置东面 target 英里处。

沿途有加油站，每个 station[i] 代表一个加油站，它位于出发位置东面 station[i][0] 英里处，并且有 station[i][1] 升汽油。

假设汽车油箱的容量是无限的，其中最初有 startFuel 升燃料。它每行驶 1 英里就会用掉 1 升汽油。

当汽车到达加油站时，它可能停下来加油，将所有汽油从加油站转移到汽车中。

为了到达目的地，汽车所必要的最低加油次数是多少？如果无法到达目的地，则返回 -1 。

注意：如果汽车到达加油站时剩余燃料为 0，它仍然可以在那里加油。如果汽车到达目的地时剩余燃料为 0，仍然认为它已经到达目的地。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/minimum-number-of-refueling-stops
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

示例

思路

动态规划

由于能否到达目的地是由油量决定的，我们可以维护一个dp,dp[i]表示加i次油可以走的最大路程,并且dp[i]是由dp[i-1]决定的。

初始时dp[0] = startFuel,表示不加油能走的最大路程

我们每次路过一个加油站就动态的更新dp[i](i <= 路过的加油站)，然后遍历dp，找到第一个大于等于target的i即为答案，若不存在，返回-1。

贪心

针对本题，我们可以动态规划，也可以贪心结合优先队列

对于优先队列可以用最小堆，也可以自制一个优先队列，定义一个数组保存经过的加油站的油量，再对这个数组进行简单处理，我们每存一个元素，就对数组进行降序排序(快速排序)，那么靠前面的就是最大的油量

我们一路向前，将经过的加油站油量保存在数组中，当油量达不到下一个加油站时，到数组中取最大值，如果还是达不到再取，直到能到下一个加油站或者数组为了空，能达到下一个加油站就重复之前的操作，数组为空了还是不能到下一个加油站则表明到不了返回-1即可，

代码

动态规划

#define MAX(a, b) ((a) > (b) ? (a) : (b))
/*
*计算最小加油次数
*/

int minRefuelStops(int target, int startFuel, int** stations, int stationsSize, int* stationsColSize){
    long * dp = malloc(sizeof(long) * (stationsSize+1));//创建dp
    memset(dp, 0, sizeof(long) * (stationsSize+1));//初始化dp
    dp[0] = startFuel;//初始时dp[0] = startFuel,表示不加油能走的最大路程
    //遍历加油站
    for(int i = 0; i < stationsSize; i++){
        for(int j = i; j >= 0; j--){//更新加油次数最大路程
            if(dp[j] >= stations[i][0]){//加油次数最大路程能到当前加油站
                dp[j+1] = MAX(dp[j+1] , dp[j] + stations[i][1]);
            }
        }
    }
    for(int i = 0; i <= stationsSize; i++){
        if(dp[i] >= target){
            return i;
        }
    }
    return -1;
}

贪心 

int cmp(const void * a, const void * b)
{
    return *(int *)b - *(int *)a;
}
int minRefuelStops(int target, int startFuel, int** stations, int stationsSize, int* stationsColSize){
    int * ans = malloc(sizeof(int) * stationsSize);//数组队列
    memset(ans, 0, sizeof(int) * stationsSize);//初始化为0
    int left = 0, right = 0;//数组左取 右存 
    int sum = startFuel;//最大行驶路程
    int num = 0;//加油次数
    int i = 0;
    while(i < stationsSize)//遍历加油站
    {
        if(sum >= stations[i][0])//当前加油站可以到，存入数组
        {
            ans[right++] = stations[i][1];
            qsort(ans, stationsSize, sizeof(ans[0]), cmp);    
            left = 0;
            i++;
        }
        else//当前加油站到不了，到数组中取油
        {
            while(sum < stations[i][0] && left < stationsSize)//取到数组为空，或者油量够到下一站
            {
                if(ans[left] == 0)
                {
                    return -1;
                }
                sum += ans[left];
                num++;
                ans[left] = 0;
                left++;
            }
        }
    }
    if(sum >= target)
    {
        return num;
    }
    while(left < stationsSize)//所有加油站都过了，每次取最大值油，判断能不能到最后
    {
        sum += ans[left];
        ans[left] = 0;
        left++;
        num++;
        if(sum >= target)
        {
            return num;
        }
    }
    return -1;
}

时间空间复杂度