Leetcode 57 Insert Interval

题目

Given a set of non-overlapping intervals, insert a new interval into the intervals (merge if necessary).

You may assume that the intervals were initially sorted according to their start times.

Example 1:
Input: intervals = [[1,3],[6,9]], newInterval = [2,5]
Output: [[1,5],[6,9]]

Example 2:
Input: intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
Output: [[1,2],[3,10],[12,16]]
Explanation: Because the new interval [4,8] overlaps with [3,5],[6,7],[8,10].

思路

没有什么特别的想法，因为要求返回数组，所以先遍历了一遍算下最终结果应该是intervals中非重叠的区间数+1，这个1有两种可能，newInterval本身或者是融合过后的新区间，记录insertIndex是为了处理第一种情况。

如果是第一种情况，此时有count == intervals.length，处理直接在对应的位置index == insertIndex时加入该区间，其余区间直接加入。
第二种情况的话就是合并区间，对每个重叠的区间取左边界最小值$min$，右边界最大值$max$。
最后处理特殊情况，以上两种情况都有可能，最后新加的那个区间是最后那个区间，这时算完max后就已经出循环了，所以考虑比较index和count+1，判断数组是否有加满，如果缺一个在补上，min未更新时对应第一种情况。

代码

class Solution {
    public int[][] insert(int[][] intervals, int[] newInterval) {
        int count = 0, insertIndex = 0;
        for (int[] interval : intervals) {
            if (newInterval[0] > interval[1]) {
                count++;
                insertIndex++;
            }
            if (newInterval[1] < interval[0]) {
                count++;
            }
        }
        int[][] res = new int[count + 1][2];
        int index = 0, min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;
        boolean flag = false;
        for (int[] interval : intervals) {
            if (count == intervals.length && index == insertIndex) {
                res[index++] = newInterval;
            }
            if (newInterval[0] > interval[1] || newInterval[1] < interval[0]) {
                if (flag) {
                    res[index++] = new int[] {min, max};
                    flag = false;
                }
                res[index++] = interval;
            } else {
                min = Math.min(Math.min(interval[0], newInterval[0]), min);
                max = Math.max(Math.max(interval[1], newInterval[1]), max);
                flag = true;
            }
        }
        if (index != count + 1) res[index] = min == Integer.MAX_VALUE ? newInterval : new int[] {min, max};
        return res;
        
    }
}

优化

之前的分类不够清晰，因为没有判断好重叠停止的条件(intervals[index][0] > newInterval[1])，所以把添加叠加区间放到后面去完成，多出来了一些边界情况，修改如下。

class Solution {
    public int[][] insert(int[][] intervals, int[] newInterval) {
        int count = 0;
        for (int[] interval : intervals) {
            if (newInterval[0] > interval[1] || newInterval[1] < interval[0]) {
                count++;
            }
        }
        int[][] res = new int[count + 1][2];
        int index = 0, indexRes = 0;
        while (index < intervals.length && intervals[index][1] < newInterval[0]) {
            res[indexRes++] = intervals[index++];
        }
        while(index < intervals.length && intervals[index][0] <= newInterval[1]){
            newInterval[0] = Math.min(intervals[index][0], newInterval[0]);
            newInterval[1] = Math.max(intervals[index][1], newInterval[1]);
            index++;
        }
        res[indexRes++] = newInterval;
        while (index < intervals.length) {
            res[indexRes++] = intervals[index++];
        }
        return res;
    }
}

同时可以直接使用List<int[]>，最后使用res.toArray(new int[res.size()][])转化。