455.分发饼干

力扣链接
假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。

对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。

思路1 大饼干喂大小孩

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        # 贪心，用大饼干喂大小孩
        g.sort() 
        s.sort()
        cnt = 0
        index = len(s)-1 # 遍历饼干的索引
        for i in range(len(g)-1,-1,-1):
            if index >= 0 and s[index]>=g[i]: #如果能喂饱，就挑下一个饼干喂,否则还是用同一块饼干喂更小的小孩
                cnt += 1
                index -= 1
        return cnt

思路2 小小孩吃小饼干

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        # 贪心，用小小孩吃小饼干
        g.sort()
        s.sort()
        cnt = 0
        index = 0 # 遍历小孩的索引

        for i in range(len(s)):# 遍历饼干
            if index < len(g) and s[i]>=g[index]:#如果能喂饱，指向下一个小孩,否则用同一个小孩吃更大的饼干
                cnt += 1
                index += 1
        return cnt

376.摆动序列

力扣链接
如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为 摆动序列 。第一个差（如果存在的话）可能是正数或负数。仅有一个元素或者含两个不等元素的序列也视作摆动序列。
子序列 可以通过从原始序列中删除一些（也可以不删除）元素来获得，剩下的元素保持其原始顺序。
给你一个整数数组 nums ，返回 nums 中作为 摆动序列 的 最长子序列的长度 。

思路 删除单一坡度上的节点，保留峰值

class Solution:
    def wiggleMaxLength(self, nums: List[int]) -> int:
        if len(nums)==1:
            return 1
        if len(nums)==2: 
            if nums[0]!=nums[1]:
                return 2
            else:
                return 1
        
        prediff = 0 # i - i-1
        curdiff = 0 # i+1 - i
        cnt = 1
        for i in range(len(nums)-1):
            curdiff = nums[i+1]-nums[i]
            if (curdiff<0 and prediff>=0) or (curdiff>0 and prediff<=0):# 如果遇到一个峰值
                cnt += 1
                prediff = curdiff
        return cnt

53.最大子序和

力扣链接
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

思路1 暴力

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        res = nums[0]
        for left in range(len(nums)):
            cursum = 0
            for right in range(left,len(nums)):
                cursum += nums[right]
                res = max(cursum, res)
        
        return res

但是这样会超时

思路2 贪心

如果 -2 1 在一起，计算起点的时候，一定是从 1 开始计算，因为负数只会拉低总和。
局部最优：当前“连续和”为负数的时候立刻放弃，从下一个元素重新计算“连续和”，因为负数加上下一个元素 “连续和”只会越来越小。
遍历 nums，从头开始用 count 累积，如果 count 一旦加上 nums[i]变为负数，那么就应该从 nums[i+1]开始从 0 累积 count 了，因为已经变为负数的 count，只会拖累总和。

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        res = nums[0]
        cursum = 0
        for i in range(len(nums)):
            cursum += nums[i]
            if cursum > res:
                res = cursum
            
            if cursum <= 0:# 如果当前和<=0，则另开一次
                cursum = 0
        return res