算法工程师第二十六天（用最少数量的箭引爆气球 无重叠区间 划分字母区间）

一、用最少数量的箭引爆气球

        有一些球形气球贴在一堵用 XY 平面表示的墙面上。墙面上的气球记录在整数数组 points ，其中points[i] = [xstart, xend] 表示水平直径在 xstart 和 xend之间的气球。你不知道气球的确切 y 坐标。

一支弓箭可以沿着 x 轴从不同点 完全垂直 地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足  xstart ≤ x ≤ xend，则该气球会被 引爆 。可以射出的弓箭的数量 没有限制 。 弓箭一旦被射出之后，可以无限地前进。

给你一个数组 points ，返回引爆所有气球所必须射出的 最小 弓箭数 。

示例 1：

输入：points = [[10,16],[2,8],[1,6],[7,12]]
输出：2
解释：气球可以用2支箭来爆破:
-在x = 6处射出箭，击破气球[2,8]和[1,6]。
-在x = 11处发射箭，击破气球[10,16]和[7,12]。

示例 2：

输入：points = [[1,2],[3,4],[5,6],[7,8]]
输出：4
解释：每个气球需要射出一支箭，总共需要4支箭。

示例 3：

输入：points = [[1,2],[2,3],[3,4],[4,5]]
输出：2
解释：气球可以用2支箭来爆破:
- 在x = 2处发射箭，击破气球[1,2]和[2,3]。
- 在x = 4处射出箭，击破气球[3,4]和[4,5]。

问题分析：要使用弓箭最小，则需要让更多的气球重叠，则需要排序，根据那个排序都行，这里，我们根据的是第一个参数排序，然后如果长度为零，那么返回0，如果不为零，那么最后的情况就是只用一只剑，所以我们初始化剑的数量为1，那么我们遍历从1开始，为什么从1开始呢？因为有比较是否重叠，然后与前面的气球相比，如果当前的气球的左边间大于上一个气球的右边间，那么这两个肯定不相邻，那么就需要一个弓箭，因为我们已经排好序了，否则它们相邻，那么问题来了？究竟有几个气球是相邻的呢？现在我们只知道当前与之前的气球相邻，不知道是否与后面的气球相邻，解决办法就是，求出这2个气球右边间的最小值（因为这样才保证这2个气球相邻（是射爆2个气球的最低要求））这样才能保证当前与之前和后是否重合，取更新当前气球的右边间，为什么更新当前气球的右边间呢？因为要和下一个作比较。

class Solution(object):
    def findMinArrowShots(self, points):
        """
        :type points: List[List[int]]
        :rtype: int
        """
        if not points:
            return 0
        points.sort(key = lambda x: x[0])
        result = 1 # 最小要使用一个弓箭
        for i in range(1, len(points)):
            if points[i][0] > points[i - 1][1]:  # 当前这个气球的左边间大于前一个气球的右边间
                result += 1
            else:
                points[i][1] = min(points[i][1], points[i - 1][1])  # 判断是否有多个重叠
        return result

二、无重叠区间

给定一个区间的集合 intervals ，其中 intervals[i] = [starti, endi] 。返回 需要移除区间的最小数量，使剩余区间互不重叠 。

示例 1:

输入: intervals = [[1,2],[2,3],[3,4],[1,3]]
输出: 1
解释: 移除 [1,3] 后，剩下的区间没有重叠。

示例 2:

输入: intervals = [ [1,2], [1,2], [1,2] ]
输出: 2
解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。

示例 3:

输入: intervals = [ [1,2], [2,3] ]
输出: 0
解释: 你不需要移除任何区间，因为它们已经是无重叠的了。

问题分析：删除最小，其实就是求相邻的区间重叠有多少个。

class Solution(object):
    def eraseOverlapIntervals(self, intervals):
        """
        :type intervals: List[List[int]]
        :rtype: int
        """

        if not intervals:
            return 0
        result = 0
        intervals.sort(key = lambda x: x[0])
        for i in range(1, len(intervals)):
            if intervals[i][0] < intervals[i - 1][1]:
                intervals[i][1] = min(intervals[i - 1][1], intervals[i][1])
                result += 1
        return result

三、划分字母区间

给你一个字符串 s 。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。

注意，划分结果需要满足：将所有划分结果按顺序连接，得到的字符串仍然是 s 。

返回一个表示每个字符串片段的长度的列表。

示例 1：

输入：s = "ababcbacadefegdehijhklij"
输出：[9,7,8]
解释：
划分结果为 "ababcbaca"、"defegde"、"hijhklij" 。
每个字母最多出现在一个片段中。
像 "ababcbacadefegde", "hijhklij" 这样的划分是错误的，因为划分的片段数较少。 

问题分析：因为一个字母只能出现在一个区间内，所以我们要求出每个字母最后一个字母所在的位置，需要2个变量，来记录每个区间的开始位置和结束位置，然后求出长度即可。为什么需要2个变量来存储呢？因为每个区间的开始和结束位置都不一样。

class Solution(object):
    def partitionLabels(self, s):
        """
        :type s: str
        :rtype: List[int]
        """
        dic = {}  # 存储每个字母的最远距离
        for index, value in enumerate(s):
            dic[value] = index
        result = []
        start = 0 # 记录每个区间的开始位置
        end = 0 # 记录每个区间的结束位置
        for index, value in enumerate(s):
            end = max(end, dic[value]) # 因为要包含所以区间字母的所有字母
            if index == end: # 已近遍历到了一个分割点
                result.append(end - start + 1)
                start = index + 1 # 更新掉一个区间的开始位置
        return result