LeetCode 最低加油次数（优先队列+贪心策略）

版权声明：本文为博主原创文章，博客地址：https://blog.csdn.net/qq_41855420，未经博主允许不得转载。 https://blog.csdn.net/qq_41855420/article/details/91356571

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

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

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

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

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

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

示例 1：

输入：target = 1, startFuel = 1, stations = []
输出：0
解释：我们可以在不加油的情况下到达目的地。

示例 2：

输入：target = 100, startFuel = 1, stations = [[10,100]]
输出：-1
解释：我们无法抵达目的地，甚至无法到达第一个加油站。

示例 3：

输入：target = 100, startFuel = 10, stations = [[10,60],[20,30],[30,30],[60,40]]
输出：2
解释：
我们出发时有 10 升燃料。
我们开车来到距起点 10 英里处的加油站，消耗 10 升燃料。将汽油从 0 升加到 60 升。
然后，我们从 10 英里处的加油站开到 60 英里处的加油站（消耗 50 升燃料），
并将汽油从 10 升加到 50 升。然后我们开车抵达目的地。
我们沿途在1两个加油站停靠，所以返回 2 。

提示：

1 <= target, startFuel, stations[i][1] <= 10^9
0 <= stations.length <= 500
0 < stations[0][0] < stations[1][0] < ... < stations[stations.length-1][0] < target

$\color{blue}思路分析：$典型的最优解问题，一般处理最优解涉及到图的时候一般是使用搜索技术（比如深度、广度优先搜索等），涉及到数组一般是使用动态规划、贪心策略这两种算法。

首先我采用的动态规划算法，其中dp[i][j]表示的到达第i - 1个站（并且在第i个站加油），一共加油j次时剩余的油。

class Solution {
public:
    int minRefuelStops(int target, int startFuel, vector<vector<int>>& stations) {
        int stationsSize = stations.size();
        if (startFuel >= target){
            return 0;
        }
        int minRes = INT_MAX;//最少加油的次数
        //dp[i][j]表示的到达第i - 1个站（并且在第i个站加油），一共加油j次时剩余的油。
        vector<vector<long>> dp(stationsSize + 1, vector<long>(stationsSize + 1, -1));
        dp[0][0] = startFuel;
        for (int i = 1; i <= stationsSize; ++i){//到达第 i - 1 站
            if (dp[0][0] >= stations[i - 1][0]){//不加油就能到达第 i - 1站
                dp[i][1] = dp[0][0] - stations[i - 1][0] + stations[i - 1][1];
                if (dp[i][1] >= target - stations[i - 1][0]){//检测加完油后，能否直接到达target
                    return 1;
                }
            }
            for (int j = 2; j <= i && j < minRes; ++j){//到达i一共加油j次
                for (int k = j - 1; k < i; ++k){//到达k的时候加油一共加油 j - 1 次
                //再从第k - 1站一次性移动到第i - 1站
					if (dp[k][j - 1] >= stations[i - 1][0] - stations[k - 1][0]){
                        dp[i][j] = max(dp[i][j], dp[k][j - 1] - stations[i - 1][0] + stations[k - 1][0] + stations[i - 1][1]);//stations[i - 1][1])是第i - 1站存储的油
                        if (dp[i][j] >= target - stations[i - 1][0]){//检测是否能够直接到达第j站
                            minRes = j;
                        }
                    }
                }
            }
        }
        return minRes == INT_MAX ? -1 : minRes;
    }
};

心疼自几啊，枯辽~
经过翻阅评论区，发现一种使用优先队列+贪心策略的思路。

此算法的核心是，我们不必在意当前剩余多少油，我们只注意当前能走到那个站，并且使用优先队列保存所有已经经过的站所存储的油，当我们的不能到达下一个站时，这时我们从优先队列取出最多的油（队头），也就是说当我们油不够的时候，每次向已经经过的没有取过的存储油最多的加油站进行加油，从而达到减少加油次数的目的。

class Solution {
public:
    int minRefuelStops(int target, int startFuel, vector<vector<int>>& stations) {
        priority_queue<int> myQue;//优先队列（默认大顶堆）
        int nowFuel = startFuel, minRes = 0;//nowFuel是我们拥有的油，minRes是最少的加油次数
        int stationsSize = stations.size(), index = 0;
        while (index < stationsSize && stations[index][0] <= nowFuel){
            while (index < stationsSize && stations[index][0] <= nowFuel){
                //如果我们能够到达这个加油站
                myQue.push(stations[index++][1]);//将这个加油站储存的油放入队列（以便下次取出最大的油）
            }
            if (index < stationsSize){
                //当我们不能到达下一个站时，这时就得加油
                while (!myQue.empty() && stations[index][0] > nowFuel){
                    minRes += 1;//加油次数自增
                    nowFuel += myQue.top();//每次取出最多的油
                    myQue.pop();
                }
            }
        }
        //如果拥有的油不足行驶到target，只能一直加油
        while (nowFuel < target && !myQue.empty()){
            minRes += 1;//加油次数自增
            nowFuel += myQue.top();//每次取出最多的油
            myQue.pop();
        }
        return nowFuel < target ? -1 : minRes;
    }
};