代码随想录算法训练营第三十六天 435. 无重叠区间 、 763.划分字母区间、 56. 合并区间

代码随想录算法训练营第三十六天 | 435. 无重叠区间 、 763.划分字母区间、 56. 合并区间

435. 无重叠区间

题目链接：435. 无重叠区间 - 力扣（LeetCode）

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        // 根据左边界的坐标从小到大排序
        // 使用Integer内置比较方法，不会溢出
        Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));

        int count = 1;  // points 不为空至少需要一支箭
        for (int i = 1; i < intervals.length; i++) {
            if (intervals[i][0] >= intervals[i - 1][1]) {  // 区间i和区间i-1不挨着，注意这里是>=
                count++; // 那么区间i需要一支箭（因为从i = 1开始遍历，i = 0至少需要一只箭，所以count初始化为1）
            } else {  // 区间i和区间i-1挨着
                intervals[i][1] = Math.min(intervals[i][1], intervals[i - 1][1]); // 更新重叠区间最小右边界
                // 因为两个区间挨着，而且前一个（i-1）肯定已经用了一只箭了，这里直接更新重叠的
                // 为了使后续的不考虑当前的区间，将当前区间右边界更新为挨在一起（可能不止这两个）区间中的最小值
                // 要是后续的区间左边界与当前连在一起的区间最小右边界重合，则当前使用了的弓箭对后续区间仍有效
            }
        }
        return intervals.length - count;
    }
}

763.划分字母区间

题目链接：763. 划分字母区间 - 力扣（LeetCode）

class Solution {
    public List<Integer> partitionLabels(String s) {
        List<Integer> result = new ArrayList<>();

        // 记录每个字符最后出现的位置
        Map<Character, Integer> lastOccurrence = new HashMap<>();
        for (int i = 0; i < s.length(); i++) {
            lastOccurrence.put(s.charAt(i), i);
        }

        int start = 0; // 当前子串的起始位置
        int end = 0;   // 当前子串的结束位置

        for (int i = 0; i < s.length(); i++) {
            char currentChar = s.charAt(i);
            // 更新当前子串的结束位置为当前字符的最后出现位置
            end = Math.max(end, lastOccurrence.get(currentChar));
            // 如何理解？ 其实end就是max跳跃问题2中的border，border表示当前能够划分的最远位置
            // 如果当前位置等于当前子串的结束位置，则找到一个划分点
            if (i == end) {
                result.add(end - start + 1);
                // 更新下一个子串的起始位置
                start = end + 1;
            }
        }

        return result;
    }
}

56. 合并区间

题目链接：56. 合并区间 - 力扣（LeetCode）

class Solution {
    public int[][] merge(int[][] intervals) {
        if(intervals.length == 0) {
            return new int[0][2];
        }

        Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
        List<int[]> merged = new ArrayList<>();
        for(int i = 0; i < intervals.length; ++i) {
            // 获取当前的区间的左右端点
            int L = intervals[i][0], R = intervals[i][1];
            // 如果是第一个区间， 或者当前区间与前一个区间不重叠，直接添加
            if(merged.size() == 0 || merged.get(merged.size() - 1)[1] < L) {
                merged.add(new int[]{L, R});
            } else {
                merged.get(merged.size() - 1)[1] = Math.max(merged.get(merged.size() - 1)[1], R);
            }
        }

        return merged.toArray(new int[merged.size()][]);
    }
}

总结

掌握数组的Lambda排序方法

 Arrays.sort(nums, (a, b) -> (a[0] - b[0])); 

这样就是升序排序，若a[0] - b[0] < 0, a 在前 b 在后

若a[0] - b[0] >= 0, b 在前 a 在后
2.

 Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));

实现的排序同上，但是这样使用Integer内置比较方法，不会溢出