贪心算法第一天 ● 455.分发饼干 ● 376. 摆动序列 ● 53. 最大子序和

理论基础：

贪心的本质是选择每一阶段的局部最优，从而达到全局最优。

455.分发饼干

可以这样想 ：局部最优就是大饼干喂给胃口大的，充分利用饼干尺寸喂饱一个，全局最优就是喂饱尽可能多的小孩。

#大饼干优先
class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        g.sort()
        s.sort()
        index=len(s)-1
        res=0
        for i in range(len(g)-1,-1,-1): #遍历从最后一个孩子往前遍历
            if index>=0 and s[index]>=g[i]:
                res+=1
                index-=1
        return res

#小饼干优先的代码
class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        g.sort()
        s.sort()
        index=0
        for i in range(len(s)): #遍历饼干
            if index<len(g) and g[index]<=s[i]:
                index+=1
        return index

376. 摆动序列

例如

可以看出 

局部最优：删除单调坡度上的节点（不包括单调坡度两端的节点），那么这个坡度就可以有两个局部峰值。

整体最优：整个序列有最多的局部峰值，从而达到最长摆动序列。

class Solution:
    def wiggleMaxLength(self, nums: List[int]) -> int:
        if len(nums)<=1:
            return len(nums)
        prediff,curdiff,res=0,0,1
        for i in range(len(nums)-1):
            curdiff=nums[i+1]-nums[i]
            if (prediff<=0 and curdiff>0) or (prediff>=0 and curdiff<0):
                res+=1
                prediff=curdiff
        return res

只要保持峰值，删除单一坡度上的节点就好

#动态规划
class Solution:
    def wiggleMaxLength(self, nums: List[int]) -> int:
        n=len(nums)
        if n<2:
            return 1
        up=down=1
        for i in range(1,n):
            if nums[i]>nums[i-1]:
                up=down+1
            elif nums[i]<nums[i-1]:
                down=up+1
        return max(up,down)

53. 最大子数组和

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        count=0
        res=-inf
        for i in range(len(nums)):
            count+=nums[i]
            if count>res:  #取累加数组之间的最大值 不断确定最大序列的终止位置
                res=count
            if count<0:
                count=0
        return res