区间合并类型（Merge Intervals）

Pattern: Merge Intervals，区间合并类型

介绍部分来源： 链接：https://www.zhihu.com/question/36738189/answer/908664455 作者：穷码农

区间合并模式是一个用来处理有区间重叠的很高效的技术。在设计到区间的很多问题中，通常咱们需要要么判断是否有重叠，要么合并区间，如果他们重叠的话。这个模式是这么起作用的：

给两个区间，一个是a，另外一个是b。别小看就两个区间，他们之间的关系能跑出来6种情况。详细的就看图啦。

理解和识别这六种情况，非常重要。因为这能帮你解决一大堆问题。这些问题从插入区间到优化区间合并都有。

怎么识别啥时候用合并区间模式呀？

• 当你需要产生一堆相互之间没有交集的区间的时候
• 当你听到重叠区间的时候

经典题目：

1、Merge Intervals (medium)

56. 合并区间

描述：

​ 给出一个区间的集合，请合并所有重叠的区间。

示例：

示例 1:

输入: intervals = [[1,3],[2,6],[8,10],[15,18]]
输出: [[1,6],[8,10],[15,18]]
解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

示例 2:

输入: intervals = [[1,4],[4,5]]
输出: [[1,5]]
解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。

/* a-b>0 交换ab位置，反之不交换。 即返回值为正数时，交换数组中正在比较的两个元素的位置，返回值为负数时，不交换。 
	第一个参数去比较第二个参数就是升序。
	第二个参数去比较第一个参数就是降序。
*/
Arrays.sort(int[] a, Comparator<Integer>() {
	public int compare(int a, int b){
		 return a - b;   升序
		 // return b - a;   降序
	}
})
Arrays.sort(int[][] a, (a, b) ->{return a[0]-b[0]}); // 对二维数组的第 1 列元素进行排序。

对二维数组的第 1 列元素进行排序，如下图所示：

解题思路：

public class Merge {
    public static void main(String[] args) {
        int[][] a =  {{1,9}, {2,5}, {19,20}, {10,11}, {12,20}, {0,3}, {0,1}, {0,2}};
        System.out.println(Arrays.deepToString(merge(a)));
    }

    public static int[][] merge(int[][] intervals) {
        int[][] res = new int[intervals.length][2];

        if (intervals.length == 0)
            return res;

        // 对二位数组进行排序, 对第一列进行升序排序
        Arrays.sort(intervals, (a, b) -> a[0] - b[0]);  // 与下列方式一样, Lambda 表达式速度更快。
        // Arrays.sort(intervals, Comparator.comparingInt(a -> a[0]));
        // System.out.println(Arrays.deepToString(intervals));
        
		// 行号
        int row = -1;       
        // 便利排序好的数组
        for (int[] interval : intervals) {
            // 1、如果结果是空，则直接将当前区间加入结果数组
            // 2、如果 当前区间的起始值 > 结果数组中最后区间的终止位置的值（例：结果数组（1,3）和 加入区间（4,6）-> 4 > 3 直接加入）
            // 则不需要合并，直接加入结果数组
            if (row == -1 || interval[0] > res[row][1]){
                res[++row] = interval;
            }else {
                // 否则需要合并，取 当前区间的终止值 和 结果数组中最后区间的终止值 较大的值
                res[row][1] = Math.max(interval[1], res[row][1]);
            }
        }
        // res数组长度是intervals.length，最后那个copy才能削掉多的空余位置（[0,0]）
        return Arrays.copyOf(res, row+1);
    }
}

2、Insert Interval (medium)

57. 插入区间

描述：

​ 给出一个无重叠的 ，按照区间起始端点排序的区间列表。

​ 在列表中插入一个新的区间，你需要确保列表中的区间仍然有序且不重叠（如果有必要的话，可以合并区间）。

示例：

示例 1：

输入：intervals = [[1,3],[6,9]], newInterval = [2,5]
输出：[[1,5],[6,9]]

示例 2：

输入：intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
输出：[[1,2],[3,10],[12,16]]
解释：这是因为新的区间 [4,8] 与 [3,5],[6,7],[8,10] 重叠。

class Solution {
    public int[][] insert(int[][] intervals, int[] newInterval) {
        if (newInterval.length == 0)
            return intervals;

        int[][] res = new int[intervals.length + 1][2];     // 结果放置，最多是增加一行
        int row = 0;    // 记录结果的行数
        int idx = 0;    // 记录遍历的行数

        // 遍历左区间，找到 插入的区间的左边界 小于 区间的右边界 的位置，且要保存遍历的区间
        // [4,8] 找到 4 落入的区间 [3,5]
        while (idx < intervals.length && intervals[idx][1] < newInterval[0]){
            res[row++] = intervals[idx++];
        }

        // 遍历覆盖的区间，找到 覆盖区间左边界 大于 插入的区间的右边界 的位置
        // [4,8] 找到 8 落入的区间 [8,10]
        while (idx < intervals.length && intervals[idx][0] <= newInterval[1]){
            // 取 最小值
            newInterval[0] = Math.min(intervals[idx][0], newInterval[0]);
            // 取 最大值
            // [4,8] [8,10] 8 和 10 的最大值
            newInterval[1] = Math.max(intervals[idx][1], newInterval[1]);
            idx++;
        }

        // 保存覆盖区间
        res[row++] = newInterval;

        // 继续遍历右区间，并保存
        while (idx < intervals.length){
            res[row++] = intervals[idx++];
        }

        // 返回结果, 拷贝结果行数
        return Arrays.copyOf(res, row);
    }
}

3、Intervals Intersection (medium)

986. 区间列表的交集

156. 合并区间

描述：

​ 给定两个由一些 闭区间 组成的列表，每个区间列表都是成对不相交的，并且已经排序。

​ 返回这两个区间列表的交集。

​ （形式上，闭区间 [a, b]（其中 a <= b）表示实数 x 的集合，而 a <= x <= b。两个闭区间的交集是一组实数，要么为空集，要么为闭区间。例如，[1, 3] 和 [2, 4] 的交集为 [2, 3]。）

示例：

输入：A = [[0,2],[5,10],[13,23],[24,25]], B = [[1,5],[8,12],[15,24],[25,26]]
输出：[[1,2],[5,5],[8,10],[15,23],[24,24],[25,25]]

解题思路

​ 用两个指针，分别扫描 A、B 数组，根据子区间的左右端，求出一个交集区间

​ 指针移动，直至指针越界，得到由交集区间组成的数组。

怎么求交集区间

• 注意绿色箭头，交集区间的 start 取的是 A、B 子区间中较大的左界。
• 注意红色箭头，交集区间的 end 取的是 A、B 子区间中较小的右界。
• 只要 start <= end，就形成了一个交集区间。

双指针移动的时机
求完一个交集区间后，较早结束的子区间，不可能再和别的子区间有重叠，它的指针要移动。
较长的子区间还有可能和别人重叠，它的指针暂时不动。

class Solution {
    public int[][] intervalIntersection(int[][] A, int[][] B) {
        if (A.length == 0)
            return A;
        if (B.length == 0)
            return B;

        int[][] res = new int[A.length + B.length][2];      // 结果集
        //List<int[]> result = new ArrayList<>();
        int A_row = 0;      // A 的行指针
        int B_row = 0;      // B 的行指针

        int idx = 0;        // 记录结果集行数

        while (A_row < A.length && B_row < B.length){
            int start = Math.max(A[A_row][0], B[B_row][0]);     // 取两个区间最大的开始值
            int end = Math.min(A[A_row][1], B[B_row][1]);       // 取两个区间最小的结束值
            if (start <= end){      // 重合区间
                res[idx][0] = start;
                res[idx][1] = end;
                idx++;
            }
            // 谁的区间结束，则移动指针
            if (A[A_row][1] < B[B_row][1]){      // A 的区间结束
                A_row++;
            }else {								 // B 的区间结束
                B_row++;
            }
        }

        return Arrays.copyOf(res, idx);
    }
}

4、Conflicting Appointments (medium)