Day37 LeetCode45. 跳跃游戏 II 1005. K 次取反后最大化的数组和 134. 加油站 135. 分发糖果 860. 柠檬水找零 406. 根据身高重建队列

题目：45. 跳跃游戏 II - 力扣（LeetCode）

思路：和55.跳跃游戏类似，还是要看最大的覆盖范围。

贪心的策略：局部最优：当前的移动距离尽可能的多，如果还没到终点，步数再加一。整体最优：一步尽可能多走，从而达到最小步数。

这里需要统计两个覆盖范围，当前这一步的最大覆盖和下一步最大覆盖。

如果移动下标达到了当前这一步的最大覆盖最远距离了，还没有到终点的话，那么就必须再走一步来增加覆盖范围，直到覆盖范围覆盖了终点。

代码：

class Solution {
public:
    int jump(vector<int>& nums) {
        if(nums.size() == 1) return 0;
        int cur = 0;//当前覆盖的最远距离下标
        int next = 0;//下一步覆盖的最远距离下标
        int result = 0;//记录走的最少步数
        for(int i = 0; i < nums.size(); i++){
            next = max(i + nums[i], next);//在cur范围内不断更新下一步所能覆盖的最远距离下标
            if(i == cur){//遇到当前覆盖的最远距离下标
                if(i < nums.size() - 1){// 如果当前覆盖最远距离下标不是终点
                    result++;//需要往前走一步
                    cur = next;//当前覆盖的最大范围更新成下一步覆盖的最大范围
                    if(next >= nums.size() - 1) break;// 下一步的覆盖范围已经可以达到终点，结束循环
                }else{
                    break;// 当前覆盖最远距到达集合终点，不用做ans++操作了，直接结束
                }
            }
        }
        return result;
    }
};

题目：1005. K 次取反后最大化的数组和 - 力扣（LeetCode）

思路：

贪心策略：局部最优：让绝对值大的负数变成正数，当前数值达到最大。整体最优：数值和最大。

如果将负数都转成正数了，k值依然大于0，此时的问题则是一个有序正整数序列，如何转变K次正负，让数组和达到最大。

那么又是一个贪心：局部最优：只找数值最小的正整数进行反复的反转，直到将剩余k的次数用完，那么当前数值和可以达到最大。

代码：

class Solution {
public:
    static bool cmp(int a, int b){
        return abs(a) > abs(b);
    }
    int largestSumAfterKNegations(vector<int>& nums, int k) {
        sort(nums.begin(), nums.end(), cmp);//将数组中的元素按绝对值大小从大到小排好序(值越小的负数排在越前面，同时值越小的负数取反后得到的值越大)
        int res = 0;
        for(int i = 0; i < nums.size(); i++){//从前向后遍历
            if(nums[i] < 0 && k > 0){//如果遇到负数同时反转次数大于0，将其反转成正数
                k--;
                nums[i] = -nums[i];
            }
        }
        //如果数组中元素都是正数，k的值还大于0，则对最后一个元素进行反复反转，直到把k的次数用完(剩余k如果是偶数，k % 2 == 0, 则反复反转值不变；k % 2 == 1, 则值变成相反数)
        if(k % 2) nums[nums.size() - 1] = -nums[nums.size() - 1];
        for(int num : nums){
            res += num;
        }
        return res;
    }
};

题目：134. 加油站 - 力扣（LeetCode）

思路：

        贪心：首先如果总油量减去总消耗大于等于零那么一定可以跑完一圈，说明 各个站点的加油站 剩油量rest[i]相加一定是大于等于零的。

每个加油站的剩余量rest[i]为gas[i] - cost[i]。

i从0开始累加rest[i]，和记为curSum，一旦curSum小于零，说明[0, i]区间都不能作为起始位置，因为这个区间选择任何一个位置作为起点，到i这里都会断油，那么起始位置从i+1算起，再从0计算curSum。

那么局部最优：当前累加rest[i]的和curSum一旦小于0，起始位置至少要是i+1，因为从i之前开始一定不行。全局最优：找到可以跑一圈的起始位置。

代码：

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int curSum = 0;
        int totalSum = 0;
        int start = 0;
        for(int i = 0; i < gas.size(); i++){
            curSum += gas[i] - cost[i];
            totalSum += gas[i] - cost[i];
            if(curSum < 0){ // 当前累加curSum一旦小于0，说明说明[0, i]区间都不能作为起始位置，因为这个区间选择任何一个位置作为起点，到i这里都会断油
                start = i + 1;//起始位置更新为i + 1
                curSum = 0;//curSum从0开始累加
            }
        }
        if(totalSum < 0) return -1;//说明怎么走都不可能走完一圈
        return start;
    }
};

题目：135. 分发糖果 - 力扣（LeetCode）

思路：

两次贪心：

第一次：从左到右遍历，只比较右边比左边评分高的情况，candyvec[i] = candy[i - 1] + 1；

第二次：从右到左遍历，只比较左边比右边评分高的情况，candyvec[i] = max(candyvec[i + 1] + 1, candyvec[i])。注意，此时candyvec[i]（第i个小孩的糖果数量）就有两个选择了，一个是candyvec[i + 1] + 1（从右边这个加1得到的糖果数量），一个是candyvec[i]（之前比较右孩子大于左孩子得到的糖果数量），取candyVec[i + 1] + 1 和 candyVec[i] 最大的糖果数量，保证第i个小孩的糖果数量既大于左边的也大于右边的。

代码：

class Solution {
public:
    int candy(vector<int>& ratings) {
        vector<int> candyvec(ratings.size(), 1);
        //右边孩子评分比左边孩子评分高，从前往后遍历
        for(int i = 1; i < ratings.size(); i++){
            if(ratings[i] > ratings[i - 1]){
                candyvec[i] = candyvec[i - 1] + 1;//右边孩子比左边孩子糖果数量多1
            }
        }

        //左边孩子评分比右边孩子评分高，从后往前遍历
        for(int i = ratings.size() - 2; i >= 0; i--){
            if(ratings[i] > ratings[i + 1]){
                //取candyVec[i + 1] + 1 和 candyVec[i] 最大的糖果数量，保证第i个小孩的糖果数量既大于左边的也大于右边的
                candyvec[i] = max(candyvec[i + 1] + 1, candyvec[i]);
            }
        }

        //统计给孩子分发的最少糖果数量
        int res = 0;
        for(int candynum : candyvec){
            res += candynum;
        }
        return res;
    }
};

 题目：860. 柠檬水找零 - 力扣（LeetCode）

思路：

• 情况一：账单是5，直接收下。
• 情况二：账单是10，消耗一个5，增加一个10
• 情况三：账单是20，优先消耗一个10和一个5，如果不够，再消耗三个5

代码：

class Solution {
public:
    bool lemonadeChange(vector<int>& bills) {
        int five = 0, ten = 0;
        for(int bill : bills){
            //情况一
            if(bill == 5){
                five++;
            }
            //情况二
            if(bill == 10){
                if(five > 0){
                    five--;
                    ten++;
                }else return false;
            }
            //情况三
            if(bill == 20){
                if(five > 0 && ten > 0){//5美元数量和10美元数量大于0，优先消耗10美元
                    five--;
                    ten--;
                }else if(five >= 3){//5美元数量大于等于3，只能使用5美元
                    five -= 3;
                }else return false;
            }
        }
        return true;
    }
};

 题目：406. 根据身高重建队列 - 力扣（LeetCode）

思路：

        先根据身高进行由大到小排列，确定h的顺序，再根据k的值进行插入操作，这样后面的值插入到前面时也不会影响前面元素的排序。

代码：

class Solution {
public:
    //对身高h进行从大到小排序
    static bool cmp(const vector<int>& a, const vector<int>& b){
        if(a[0] == b[0]) return a[1] < b[1];//如果身高h相同，则按照k值从小到大排序
        return a[0] > b[0];
    }
    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        sort(people.begin(), people.end(), cmp);
        vector<vector<int>> queue;
        for(int i = 0; i < people.size(); i++){
            int index = people[i][1];
            queue.insert(queue.begin() + index, people[i]);
        }
        return queue;
    }
};

使用list（底层数据结构是链表）进行插入操作，减少了vector插入用于扩容和复制的时间开销。

代码：

class Solution {
public:
    //对身高h进行从大到小排序
    static bool cmp(const vector<int>& a, const vector<int>& b){
        if(a[0] == b[0]) return a[1] < b[1];//如果身高h相同，则按照k值从小到大排序
        return a[0] > b[0];
    }
    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        sort(people.begin(), people.end(), cmp);
        list<vector<int>> queue;
        for(int i = 0; i < people.size(); i++){
            int index = people[i][1];
            std::list<vector<int>>::iterator it = queue.begin();
            while(index--){
                it++;
            }
            queue.insert(it, people[i]);
        }
        return vector<vector<int>>(queue.begin(), queue.end());
    }
};