刷题第五天(优先队列,待补充）

1705. 吃苹果的最大数目

有一棵特殊的苹果树，一连 n 天，每天都可以长出若干个苹果。在第 i 天，树上会长出 apples[i] 个苹果，这些苹果将会在 days[i] 天后（也就是说，第 i + days[i] 天时）腐烂，变得无法食用。也可能有那么几天，树上不会长出新的苹果，此时用 apples[i] == 0 且 days[i] == 0 表示。

你打算每天 最多 吃一个苹果来保证营养均衡。注意，你可以在这 n 天之后继续吃苹果。

给你两个长度为 n 的整数数组 days 和 apples ，返回你可以吃掉的苹果的最大数目。

示例 1：

输入：apples = [1,2,3,5,2], days = [3,2,1,4,2]
输出：7
解释：你可以吃掉 7 个苹果：

• 第一天，你吃掉第一天长出来的苹果。
• 第二天，你吃掉一个第二天长出来的苹果。
• 第三天，你吃掉一个第二天长出来的苹果。过了这一天，第三天长出来的苹果就已经腐烂了。
• 第四天到第七天，你吃的都是第四天长出来的苹果。
  示例 2：

输入：apples = [3,0,0,0,0,2], days = [3,0,0,0,0,2]
输出：5
解释：你可以吃掉 5 个苹果：

• 第一天到第三天，你吃的都是第一天长出来的苹果。
• 第四天和第五天不吃苹果。
• 第六天和第七天，你吃的都是第六天长出来的苹果。

class Solution {
public:
    int eatenApples(vector<int>& apples, vector<int>& days) {
     priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>> >que;
     int res=0;
     int temp=apples.size()-1;
     for(int i=0;i<apples.size();i++){
         while(!que.empty()&&que.top().first==i){
             que.pop();
         }
         if(apples[i]!=0){
           que.push({days[i]+i,apples[i]}); 
         }
         if(!que.empty()){
             auto it=que.top();
             res++;
             que.pop();
             it.second--;
             if(it.second>0){
                 que.push(it);
             }
         }
         
     }
     while(!que.empty()){
       temp++;
       while(!que.empty()&&que.top().first==temp){
           que.pop();
       }
       if(!que.empty()){
             auto it=que.top();
             res++;
             que.pop();
             it.second--;
             if(it.second>0){
                 que.push(it);
         }
       }
     }
     return res;
    }
};

871. 最低加油次数

汽车从起点出发驶向目的地，该目的地位于出发位置东面 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 。

class Solution {
public:
    int minRefuelStops(int target, int startFuel, vector<vector<int>>& stations) {
        if(stations.size()==0){
            if(startFuel>=target){
                return 0;
            }
            else{
                return -1;
            }
        }
        priority_queue<pair<int,int>,vector<pair<int,int>>,less<pair<int,int>> > que;//最大堆，用来放最大的油量
         sort(stations.begin(),stations.end(),[](auto &a,auto &b){
             return a[0]<b[0]||a[0]==b[0]&&a[1]>b[1];
         });
         int res=0;
         for(int i=0;i<stations.size();i++){
           if(startFuel<stations[i][0]){
               while(!que.empty()&&startFuel<stations[i][0]){
                    res++;
                    startFuel+=que.top().first;
                    if(startFuel>=target){
                        return res;
                    }
                    que.pop();
               }
               if(startFuel<stations[i][0]){
                   return -1;
               }
           }
           que.push({stations[i][1],stations[i][0]});
         }
         while(startFuel<target&&!que.empty()){
             res++;
             startFuel+=que.top().first;
             que.pop();
         }
         if(startFuel<target){
             return -1;
         }
        return res;
    }
};

在上面代码中可以发现可以对最大堆进行优化，
因为我们发现对油量单独放入堆中即可；

class Solution {
public:
    int minRefuelStops(int target, int startFuel, vector<vector<int>>& stations) {
        if(stations.size()==0){
            if(startFuel>=target){
                return 0;
            }
            else{
                return -1;
            }
        }
        priority_queue<int> que;
         int res=0;
         for(int i=0;i<stations.size();i++){
             if(startFuel<stations[i][0]){
                 while(startFuel<stations[i][0]&&!que.empty()){
                     startFuel+=que.top();
                     que.pop();
                     res++;
                     if(startFuel>=target){
                         return res;
                     }
                 }
                 if(startFuel<stations[i][0]){
                     return -1;
                 }
             }
             que.push(stations[i][1]);
            
         }
         while(startFuel<target&&!que.empty()){
             res++;
             startFuel+=que.top();
             que.pop();
         }
         if(startFuel<target){
             return -1;
         }
         return res;
    }
};

1642. 可以到达的最远建筑

给你一个整数数组 heights ，表示建筑物的高度。另有一些砖块 bricks 和梯子 ladders 。

你从建筑物 0 开始旅程，不断向后面的建筑物移动，期间可能会用到砖块或梯子。

当从建筑物 i 移动到建筑物 i+1（下标 从 0 开始 ）时：

如果当前建筑物的高度 大于或等于 下一建筑物的高度，则不需要梯子或砖块
如果当前建筑的高度 小于 下一个建筑的高度，您可以使用 一架梯子 或 (h[i+1] - h[i]) 个砖块
如果以最佳方式使用给定的梯子和砖块，返回你可以到达的最远建筑物的下标（下标 从 0 开始 ）。

实例 1：
输入：heights = [4,2,7,6,9,14,12], bricks = 5, ladders = 1
输出：4
解释：从建筑物 0 出发，你可以按此方案完成旅程：

• 不使用砖块或梯子到达建筑物 1 ，因为 4 >= 2
• 使用 5 个砖块到达建筑物 2 。你必须使用砖块或梯子，因为 2 < 7
• 不使用砖块或梯子到达建筑物 3 ，因为 7 >= 6
• 使用唯一的梯子到达建筑物 4 。你必须使用砖块或梯子，因为 6 < 9
  无法越过建筑物 4 ，因为没有更多砖块或梯子。
  示例 2：

输入：heights = [4,12,2,7,3,18,20,3,19], bricks = 10, ladders = 2
输出：7
示例 3：

输入：heights = [14,3,19,3], bricks = 17, ladders = 0
输出：3

class Solution {
public:
    int furthestBuilding(vector<int>& heights, int bricks, int ladders) {
       priority_queue<int,vector<int>,greater<int> > que;//创建最小堆，来获取当前可能得到的最大值，用梯子来解决
       for(int i=1;i<heights.size();i++){
         int dec=heights[i]-heights[i-1];
         if(dec>0){
            que.push(dec);
            if(que.size()>ladders){
                if(bricks<que.top()){
                    return i-1;
                }
                bricks-=que.top();
                que.pop();
            }
            
         }
       }
       return heights.size()-1;
    }
};