代码随想录算法训练营第36天（贪心算法05 ● 435. 无重叠区间 ● 763.划分字母区间 ● 56. 合并区间

详细布置

今天的三道题目，都算是 重叠区间 问题，大家可以好好感受一下。 都属于那种看起来好复杂，但一看贪心解法，惊呼：这么巧妙！
还是属于那种，做过了也就会了，没做过就很难想出来。
不过大家把如下三题做了之后， 重叠区间 基本上差不多了

435. 无重叠区间

题目链接： 435. 无重叠区间
文章/视频链接： 435. 无重叠区间

解题思路

这道题和452.用最少数量的箭引爆气球思路很类似。
二者的区别仅在于

• 这道题 intervals[i][0] >= intervals[i-1][1] 算2个区间不重叠，即[1,2]和[2,3]属于两个不同的区间
• 引爆气球那道题intervals[i][0] > intervals[i-1][1] 严格大于才算2个区间不重叠，即[1,2]和[2,3]属于同一个区间，用一个弓箭即可

弓箭的数量就相当于是非交叉区间的数量，只要把弓箭那道题目代码里射爆气球的判断条件加个等号（认为[0，1][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;
    }
}

// 延续452.用最少数量的箭引爆气球 的代码稍作修改
class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        Arrays.sort(intervals, (a,b)-> {
            return Integer.compare(a[0],b[0]);
        });
        int count = 1;
        for(int i = 1;i < intervals.length;i++){
            if(intervals[i][0] >= intervals[i-1][1]){
                count++;
            }else{
                intervals[i][1] = Math.min(intervals[i][1], intervals[i-1][1]);
            }
         }
        return intervals.length - count;
    }
}

763.划分字母区间

题目链接： 763.划分字母区间
文章/视频链接： 763.划分字母区间

解题思路

可以分为如下两步：

1. 统计每一个字符最后出现的位置
2. 从头遍历字符，并更新字符的最远出现下标，如果找到字符最远出现位置下标和当前下标相等了，则找到了分割点
   

补充

这里提供一种与452.用最少数量的箭引爆气球、435.无重叠区间相同的思路。
统计字符串中所有字符的起始和结束位置，记录这些区间(实际上也就是435.无重叠区间题目里的输入)，将区间按左边界从小到大排序，找到边界将区间划分成组，互不重叠。找到的边界就是答案。
代码感觉写起来比较麻烦，可以去代码随想录上看。

// 贪心
class Solution {
    public List<Integer> partitionLabels(String s) {
        List<Integer> list = new LinkedList<>();
        int[] edge = new int[26];  //用数组模拟哈希表
        int left = 0;
        int right = 0;
        // int index = 0;
        char[] chars = s.toCharArray();
        for(int i = 0; i < chars.length; i++){
            edge[chars[i] - 'a'] = i;
        }

        for(int i = 0; i < chars.length; i++){
            right = Math.max(right, edge[chars[i] - 'a']);
            if(i == right){
                list.add(i-left+1);
                left = i + 1;
            }
        }
        return list;

    }
}

56. 合并区间

本题相对来说就比较难了。
题目链接： 56. 合并区间
文章/视频链接： 56. 合并区间

解题思路

和我们刚刚讲过的452. 用最少数量的箭引爆气球和 435. 无重叠区间 都是一个套路。
这几道题都是判断区间重叠，区别就是判断区间重叠后的逻辑，本题是判断区间重贴后要进行区间合并。

1. 先排序，让所有的相邻区间尽可能的重叠在一起，按左边界，或者右边界排序都可以，处理逻辑稍有不同。
2. 若有重叠，即intervals[i][0] <= res.getLast()[1], 用合并区间后左边界和右边界，作为一个新的区间，加入到result数组里就可以了。
   如果没有合并就把原区间加入到result数组。

不熟悉的基础语法知识

排序

Arrays.sort(intervals, (x, y) -> Integer.compare(x[0], y[0]));

list相关操作

List<int[]> res = new LinkedList<>();
res.getLast()[0]和res.getLast()[1]
res.add(new int[]{start, end})
res.add(intervals[i])
res.toArray(new int[res.size()][])

// 贪心 法1 延续之前两道重叠区间问题的思路
class Solution {
    public int[][] merge(int[][] intervals) {
        List<int[]> res = new LinkedList<>();
        //按照左边界排序
        Arrays.sort(intervals, (x, y) -> Integer.compare(x[0], y[0]));
        res.add(intervals[0]);
        for(int i = 1; i < intervals.length; i++){
            if(intervals[i][0] <= res.getLast()[1]){
                int start = res.getLast()[0];
                int end = Math.max(intervals[i][1], res.getLast()[1]);
                res.removeLast();
                res.add(new int[]{start, end});
            }else{
                res.add(intervals[i]);
            }
        }
        return res.toArray(new int[res.size()][]);
    }
}

// 贪心 法2  思路类似
class Solution {
    public int[][] merge(int[][] intervals) {
        List<int[]> res = new LinkedList<>();
        //按照左边界排序
        Arrays.sort(intervals, (x, y) -> Integer.compare(x[0], y[0]));
        //initial start 是最小左边界
        int start = intervals[0][0];
        int rightmostRightBound = intervals[0][1];
        for(int i = 1; i < intervals.length; i++){
            if(intervals[i][0] > rightmostRightBound){
                res.add(new int[]{start, rightmostRightBound});
                start = intervals[i][0];
                rightmostRightBound = intervals[i][1];
            }else{
                rightmostRightBound = Math.max(rightmostRightBound, intervals[i][1]);
            }
        }
        res.add(new int[]{start, rightmostRightBound});
        return res.toArray(new int[res.size()][]);


    }
}