代码随想录算法训练营day31 | 贪心问题：455. 分发饼干，53. 最大子数组和

目录

455. 分发饼干

​​​​​​376. 摆动序列

53. 最大子数组和

---

455. 分发饼干

类型：贪心

难度：medium

思路：

        记得先排序，用饼干去满足小孩。

代码：

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        int gLen = g.length;
        int sLen = s.length;
        int index = 0;
        Arrays.sort(g);
        Arrays.sort(s);
        // 从饼干遍历
        for (int i = 0; i < sLen; i++) {
            if (index < gLen && g[index] <= s[i]) {
                index++;
            }
        }
        return index;
    }
}

​​​​​​376. 摆动序列

类型：贪心

难度：medium

思路：

        记录波峰和波谷的数量，当preDiff和curDiff异号时，说明出现了波峰或者波谷。

        考虑三种情况：

1. 情况一：上下坡中有平坡
2. 情况二：数组首尾两端
3. 情况三：单调坡中有平坡

情况一：上下坡中有平坡

        把

(preDiff > 0 && curDiff < 0) || (preDiff < 0 && curDiff > 0)

         改为

(preDiff >= 0 && curDiff < 0) || (preDiff <= 0 && curDiff > 0)

 

情况二：数组首尾两端

        int i从1开始取，并且count初始值为1。

 情况三：单调坡中有平坡

        只有出现了波峰或者波谷时，才更新preDiff。

            if ((preDiff >= 0 && curDiff < 0) || (preDiff <= 0 && curDiff > 0)) {
                count++;
                preDiff = curDiff;
            }     

代码：

class Solution {
    public int wiggleMaxLength(int[] nums) {
        if (nums.length <= 1) {
            return nums.length;
        }
        int preDiff = 0;
        int curDiff = 0;
        int count = 1;
        for (int i = 1; i < nums.length; i++) {
            curDiff = nums[i] - nums[i - 1];
            if ((preDiff >= 0 && curDiff < 0) || (preDiff <= 0 && curDiff > 0)) {
                count++;
                preDiff = curDiff;
            }           
        }
        return count;
    }
}

53. 最大子数组和

类型：贪心

难度：medium

思路：

        从左向右遍历，记录子序列的和，当子序列为负数时，从新开始计算子序列的和。max来记录最大的子序列和。

        负数与负数相加会更小。

代码：

// // 动态规划
class Solution {
    public int maxSubArray(int[] nums) {
        if (nums.length == 1) {
            return nums[0];
        }
        int[] dp = new int[nums.length];
        dp[0] = nums[0];
        int max = dp[0];
        for (int i = 1; i < nums.length; i++) {
            dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);
            max = max > dp[i]? max: dp[i];
        }

        return max;
    }
}

// 贪心
class Solution {
    public int maxSubArray(int[] nums) {
        if (nums.length == 1) {
            return nums[0];
        }
        int max = Integer.MIN_VALUE;
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
            max = sum > max? sum: max;
            // 当连续子数组和为负数时,重新开始计算sum
            if (sum < 0) {
                sum = 0;
            }
        }
        return max;
    }
}