---

一、455. 分发饼干

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

示例 1:
输入: g = [1,2,3], s = [1,1]
输出: 1
解释:
你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。
虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。
所以你应该输出1。

示例 2:
输入: g = [1,2], s = [1,2,3]
输出: 2
解释:
你有两个孩子和三块小饼干，2个孩子的胃口值分别是1,2。
你拥有的饼干数量和尺寸都足以让所有孩子满足。
所以你应该输出2.

思路
为了满足更多的小孩，就不要造成饼干尺寸的浪费。
大尺寸的饼干既可以满足胃口大的孩子也可以满足胃口小的孩子，那么就应该优先满足胃口大的。
可以尝试使用贪心策略，先将饼干数组和小孩数组排序。
然后从后向前遍历小孩数组，用大饼干优先满足胃口大的，并统计满足小孩数量。

class S455:
    def func(self, g, s):
        s.sort()
        g.sort()
        result = 0
        index = len(s) - 1  # 饼干数组的下标，从最后一个饼干开始
        for i in range(len(g) - 1, -1, -1):
            if index >= 0 and s[index] >= g[i]:
                result += 1
                index -= 1
        return result


r = S455()
g = [1, 2, 3]
s = [1, 1]
print(r.func(g, s))

二、56. 合并区间

中等
以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。

示例 1：
输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

示例 2：
输入：intervals = [[1,4],[4,5]]
输出：[[1,5]]
解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。

思路：所以一样的套路，先排序，让所有的相邻区间尽可能的重叠在一起，按左边界，或者右边界排序都可以，处理逻辑稍有不同。
按照左边界从小到大排序之后，如果 intervals[i][0] <= intervals[i - 1][1] 即intervals[i]的左边界 <= intervals[i - 1]的右边界，则一定有重叠。（本题相邻区间也算重贴，所以是<=）

class S56:
    def func(self, nums):
        res = []  # [[1,3]]
        if len(nums) == 0:
            return res  # 区间集合为0直接返回
        nums.sort(key=lambda x: x[0])  # 按照区间的左边界进行排序
        res.append(nums[0])  # 第一个区间可以直接放入结果中

        for i in range(1, len(nums)):
            if res[-1][1] >= nums[i][0]:  # 发现重叠区间
                # 合并区间，只需要更新结果集最后一个区间的右边界，因为根据排序，左边界已经最小的
                res[-1][1] = max(res[-1][1], nums[i][1])
            else:
                res.append(nums[i])
        return res


nums = [[1, 3], [2, 6], [8, 10], [15, 18]]

三、53. 最大子数组和

中等
给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
子数组
是数组中的一个连续部分。

示例 1：
输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

示例 2：
输入：nums = [1]
输出：1

示例 3：
输入：nums = [5,4,-1,7,8]
输出：23

思路：如果前面数组和为负数，加上当前数只会让总和变小。
所以如果前面数组和为负数，直接让当前值为新的起点。从新开始遍历。
当连续和为负数的时候，直接抛弃
只要是正数加上后面的数就具有增大的效果。

class S53:
    def func(self, nums):
        result = 0  # 存放结果
        count = 0  # 记录累加和
        for i in range(len(nums)):
            count += nums[i]
            if count > result:  # 取区间累计的最大值（相当于不断确定最大值子序终止位置）
                result = count
            if count <= 0:  # 相当于重置最大子序列起始位置，因为遇到附属一定拉低总和
                count = 0
        return result


r = S53()
nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
print(r.func(nums))