夸父追日：第八章 贪心算法 part04

今日收获：用最少数量的箭引爆气球，无重叠区间，划分字母区间

1. 用最少数量的箭引爆气球

题目链接：452. - 力扣（LeetCode）

思路：

（1）局部最优：尽量用箭射到重叠最多的气球

（2）将气球尽量靠左排序，保证重叠的气球数最多。如果下一个气球的左边界在上一个气球的右边界内，则两个气球重叠，将重叠的右区间更新为重叠气球中最小的右区间，保证向右移动时这个气球可以射到；如果不重叠，则结果加1。

方法：

class Solution {
    public int findMinArrowShots(int[][] points) {
        // 将气球尽量靠左排，重叠在一起
        Arrays.sort(points,(a,b)->Integer.compare(a[0],b[0]));

        if (points.length==0){
            return 0;
        }

        int count=1;  // 至少需要一支
        for (int i=1;i<points.length;i++){
            // 不能和上一个重叠
            if (points[i][0]>points[i-1][1]){
                count++;
            }else {  // 可以重叠
                points[i][1]=Math.min(points[i-1][1],points[i][1]); // 保证重叠中右边界最小的可以射到
            }
        }

        return count;
    }
}

总结：Integer.compare()方法（留坑待填）

2. 无重叠区间

题目链接：435. - 力扣（LeetCode）

思路：

（1）上一题射箭实际是求最大的不重复区间，将区间总数减去最大不重复区间就是最小的重叠区间。

（2）求最小的重叠区间。将区间尽量向左排序，如果有区间重叠，将重叠子区间的右区间改为重叠元素中最小的右区间，便于继续判断下一个元素是否在此重叠区间内。

方法：

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        // 求重叠区间的最小个数
        // 向左排序
        Arrays.sort(intervals,(a,b)->Integer.compare(a[0],b[0]));

        int count=0;  
        for (int i=1;i<intervals.length;i++){
            if (intervals[i][0]<intervals[i-1][1]){
                count++;
                // 更新重叠区间的右区间
                intervals[i][1]=Math.min(intervals[i][1],intervals[i-1][1]);
            }
        }

        return count;
    }
}

总结：求重叠区间和不重叠区间的思路都是将区间先靠一边（比如左边）排序，求出有元素重叠之后再更新重叠区间的最小右区间，目的是判断下一个元素是否在已有的这个重叠区间内。

3. 划分字母区间

题目链接：763. - 力扣（LeetCode）

思路：遍历字符串记录每一个字符对应的最远下标。再遍历字符串时不断更新当前区间中的右边界为最远下标。如果遍历到了右边界，说明到达了分割点。

方法：

class Solution {
    public List<Integer> partitionLabels(String s) {
        // 记录每一个字符对应的最远下标
        int[] hash=new int[26];
        for (int i=0;i<s.length();i++){
            hash[s.charAt(i)-'a']=i;  // 不断被更大值覆盖
        }

        List<Integer> result=new ArrayList<>();
        int left=0;  // 区间的起点和终点
        int right=0;
        for (int i=0;i<s.length();i++){
            right=Math.max(right, hash[s.charAt(i)-'a']);  // 更新字符串区间中的最远下标
            if(i==right){  // 分割点
                result.add(right-left+1);
                left=i+1;
            }
        }

        return result;
    }
}

总结：有顺序且数量不多的元素做哈希映射时，最好利用数组存储，并将元素的值和数组下标产生联系，方便存储和读取元素对应的值。