与贪心有关的算法题

贪心算法

贪心的本质是选择每一阶段的局部最优，进而得到全局最优。没有固定的套路，需要自行判断题目是否能用贪心来做。

1. 摆动序列

1.1 思路

思路1：贪心：从前往后，不断找到峰值，即极大值和极小值，通过统计极大值和极小值的数量来得到结果，思路比较简单

1.2 代码

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        if(nums.size() <= 1){
            return nums.size();
        }
        int result = 1; //首部肯定必有一个峰值
        int pre = 0;
        int cur = 0;
        for(int i = 0; i < nums.size() - 1; i++){
            cur = nums[i + 1] - nums[i];
            if(pre >= 0 && cur < 0 || pre <= 0 && cur > 0){
                result++;
                pre = cur;
            }
        }
        return result; 
    }
};

2. 最大子数组和

2.1 思路

思路简单，但是比较难以想到。贪心的思路：当和遇到小于0时，立马抛弃，从下一位置重新开始。最大和使用一个数记录就行。

2.2 代码

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int result = nums[0];
        int i = 0;
        int sum = 0;
        while(i < nums.size()){
            sum += nums[i];
            if(sum > result){
                result = sum;
            }
            if(sum < 0){
                sum = 0;
            }
            i++;
        }
        return result;
    }
};

3. 跳跃游戏II

3.1 思路

使用贪心算法：

思路一：先找能到达最终点的最前面一个点，然后将最终点替换为找到的点，不断寻找能到达该点的最前一个点。最坏时间复杂度O(n^2)，最好时间复杂度O(1)

思路二：从前往后遍历，每一次遍历更新下一个节点的最大覆盖范围，当索引走到当前节点所能覆盖的最大范围时，需要进行更新当前节点的最大覆盖范围，同时次数加一。具体见代码

3.2 代码

class Solution {
public:
    int jump(vector<int>& nums) {
        //思路一
        int target = nums.size() - 1;
        int result = 0;
        while(target != 0){
            for(int i = 0; i < nums.size() - 1; i++){
                if(nums[i] + i >= target){
                    target = i;
                    result++;
                    break;
                }
            }
        }
        return result;
        //思路二
        // int cur = 0;
        // int next = 0;
        // int result = 0;
        // for(int i = 0; i < nums.size() - 1; i++){
        //     next = max(next, nums[i] + i);  //下一个节点所能覆盖的最远距离
        //     if(i == cur){                 //当前节点覆盖的最远距离到了则必须更新
        //         cur = next;
        //         result++;
        //     }
        // }
        // return result;
    }
};

4. K次取反后最大化数组和

4.1 思路</