java算法day36 | 贪心算法 part05 ● 435. 无重叠区间 ● 763.划分字母区间 ● 56. 合并区间

435. 无重叠区间

思路： 重叠区间典型题目，先按照左边界排序，再从左到右判断相邻区间是否重叠，重叠则删除其中一个。

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        Arrays.sort(intervals,(a,b)->{
                return Integer.compare(a[0],b[0]);
        });
        int remove=0;
        int pre = intervals[0][1];//存储上一个区间的结尾位置
        for(int i=1;i<intervals.length;i++){
            if(intervals[i][0]<pre){//当有重合时，移除结尾较大的元素
                remove++;
                pre=Math.min(pre,intervals[i][1]);//更新当前结尾为区间结尾较小的位置
            }else{
                pre=intervals[i][1];//否则直接更新pre到当前位置。
            }
        }
        return remove;
    }
}

时间复杂度：O(nlog n) ，有一个快排
空间复杂度：O(n)，有一个快排，最差情况(倒序)时，需要n次递归调用。因此确实需要O(n)的栈空间

763.划分字母区间

思路： 和45.跳跃游戏II的思路很像

在遍历的过程中相当于是要找每一个字母的边界，如果找到之前遍历过的所有字母的最远边界，说明这个边界就是分割点了。此时前面出现过所有字母，最远也就到这个边界了。

可以分为如下两步：

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

class Solution {
    public List<Integer> partitionLabels(String s) {
        int[] list=new int[26];//存储字符的最远位置
        char[] sList=s.toCharArray();
        for(int i=0;i<sList.length;i++){//初始化最远位置数组
            list[sList[i]-'a']=i;
        }
        List<Integer> res=new ArrayList<>();
        int end=0;//这一步的最远位置
        int len=0;//当前走的长度
        for(int i=0;i<sList.length;i++){
            len++;
            end=Math.max(end,list[sList[i]-'a']);
            if(i==end) {
                res.add(len);
                len=0;
            }
        }
        return res;
    }
}

时间复杂度：O(n)
空间复杂度：O(1)，使用的hash数组是固定大小

56. 合并区间

思路： 本题的本质其实还是判断重叠区间问题。

和 452. 用最少数量的箭引爆气球和 435. 无重叠区间都是一个套路。

这几道题都是判断区间重叠，区别就是判断区间重叠后的逻辑，本题是判断区间重贴后要进行区间合并。

class Solution {
    public int[][] merge(int[][] intervals) {
        Arrays.sort(intervals,(a,b)->Integer.compare(a[0],b[0]));
        int start=intervals[0][0];//动态的开始位置
        int end=intervals[0][1];//结束位置
        List<int[]> res=new ArrayList<>();
        for(int i=1;i<intervals.length;i++){
            if(intervals[i][0]<=end){//如果有重合
                end=Math.max(intervals[i][1],end);//更新end位置
            }
            else{//没有重合则添加到结果中，并更新start和end的位置
                res.add(new int[]{start,end});
                start=intervals[i][0];
                end=intervals[i][1];
            }
        }
        res.add(new int[]{start,end}); 
        return res.toArray(new int[res.size()][]);
    }
}

时间复杂度: O(nlogn)
空间复杂度: O(logn)，排序需要的空间开销