随想录一刷Day31——贪心算法

Day31_贪心算法

1. 贪心算法理论基础

通过局部最优，推出整体最优。

1. 分发饼干

455. 分发饼干
思路

1. 将孩子的胃口和饼干的大小升序排序
2. 从最小胃口的孩子开始，找能满足他胃口的最小的饼干
3. 重复至每个孩子都有饼干吃，或者没有饼干能满足剩下的孩子，则分配结束

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        int g_len = g.size();
        int s_len = s.size();
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());

        int i = 0, j = 0, cnt = 0;
        while (i < g_len && j < s_len) {
            if (g[i] <= s[j]) {
                i++;
                j++;
                cnt++;
            } else {
                j++;
            }
        }
        return cnt;
    }
};

还可以反过来想，用最大的食物满足胃口最大的孩子。

3. 摆动序列

376. 摆动序列

计算出现拐点的地方，开始一个数就记为1，之后每出现一个拐点，就将将答案+1

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        int nums_size = nums.size();
        if (nums_size <= 1) return nums_size;
        int pre_diff = 0, cur_diff = 0;
        int cnt = 1;
        for (int i = 0; i < nums_size - 1; ++i) {
            cur_diff = nums[i + 1] - nums[i];
            // 当前差值和前一个差值异号，或者一开始由平缓趋于变化，说明出现了拐点
            if ((cur_diff > 0 && pre_diff <= 0) || cur_diff < 0 && pre_diff >= 0) {
                pre_diff = cur_diff;
                cnt++;
            }
        }
        return cnt;
    }
};

4. 最大子数组和

53. 最大子数组和

贪心的对数组依次求和，不断更新答案为和的最大值。当出现和小于0的情况时，对下一个数字来说，重新开始求和，得到的和更大，所以遇到连续和小于0时。丢弃该连续区间，重新选择区间求和。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int nums_size = nums.size();
        int sum = 0;
        int max_ans = nums[0];
        for (int i = 0; i < nums_size; ++i) {
            if (sum + nums[i] < 0) { // 如果当前的连续和小于0，则从下一个元素开始重新求和
                max_ans = max(max_ans, nums[i]); // 更新答案
                sum = 0;
                continue;
            }
            sum += nums[i];
            max_ans = max(max_ans, sum); // 更新答案
        }
        return max_ans;
    }
};