leetcode 56 middle

package leetcode.sort;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
* @Description: 给出一个区间的集合，请合并所有重叠的区间。

示例 1:

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

输入: [[1,4],[4,5]]
输出: [[1,5]]
解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。
 
* @Param:  
* @return:  
* @Author: lvhong
* @Date:  
* @E-mail [email protected]
*/ 
public class lab56 {
    /** 
    * @Description:    //注：此想法来自leetcode 用户 powcai 简化版的排序实现 创建了一个新的ArrayList对原始数据进行排序，之后通过判断两个区间之间左右区间的大小比值来确定有没有重合，将合并后的数组放在一个新的数组内部
    * @Param:  
    * @return:  
    * @Author: lvhong
    * @Date:  
    * @E-mail [email protected]
    */
    public int[][] merge(int[][] intervals) {
        List<int []> res = new ArrayList<>();
        if(intervals.length<2||intervals==null) return intervals;
        Arrays.sort(intervals, (a, b) -> a[0] - b[0]);     //这是本地的lamada优化
//这是一个lamada表达式，表示将二维数组内的元素大小排序  //原作者的源码
//        Arrays.sort(arr,new Comparator<int[]>(){
//            @Override
//            public int compare(int[] a,int[] b){
//                return a[0]-b[0];
//            }
//        });
        int i=0;
        while(i<intervals.length){
            int left = intervals[i][0];
            int right = intervals[i][1];
            while(i<intervals.length-1 && right>=intervals[i+1][0]){
                i++;
                right=Math.max(right,intervals[i][1]);  //此处判断当前子数组的县一个数组的左值小于当前右值（既重叠）比较两个右值
            }
            res.add(new int[]{left,right});
            i++;
        }
        return res.toArray(new int[0][]);
    }
}

官方解法
思路

如果我们按照区间的左端点排序，那么在排完序的列表中，可以合并的区间一定是连续的。如下图所示，标记为蓝色、黄色和绿色的区间分别可以合并成一个大区间，它们在排完序的列表中是连续的：

算法

我们用数组 merged 存储最终的答案。

首先，我们将列表中的区间按照左端点升序排序。然后我们将第一个区间加入 merged 数组中，并按顺序依次考虑之后的每个区间：

如果当前区间的左端点在数组 merged 中最后一个区间的右端点之后，那么它们不会重合，我们可以直接将这个区间加入数组 merged 的末尾；

否则，它们重合，我们需要用当前区间的右端点更新数组 merged 中最后一个区间的右端点，将其置为二者的较大值。

正确性证明

上述算法的正确性可以用反证法来证明：在排完序后的数组中，两个本应合并的区间没能被合并，那么说明存在这样的三元组 (i, j, k)(i,j,k) 以及数组中的三个区间 a[i], a[j], a[k]a[i],a[j],a[k] 满足 i < j < ki<j<k 并且 (a[i], a[k])(a[i],a[k]) 可以合并，但 (a[i], a[j])(a[i],a[j]) 和 (a[j], a[k])(a[j],a[k]) 不能合并。这说明它们满足下面的不等式：

a[i].end < a[j].start \quad (a[i] \text{ 和 } a[j] \text{ 不能合并}) \\ a[j].end < a[k].start \quad (a[j] \text{ 和 } a[k] \text{ 不能合并}) \\ a[i].end \geq a[k].start \quad (a[i] \text{ 和 } a[k] \text{ 可以合并}) \\
a[i].end<a[j].start(a[i] 和 a[j] 不能合并)
a[j].end<a[k].start(a[j] 和 a[k] 不能合并)
a[i].end≥a[k].start(a[i] 和 a[k] 可以合并)

我们联立这些不等式（注意还有一个显然的不等式 a[j].start \leq a[j].enda[j].start≤a[j].end），可以得到：

a[i].end < a[j].start \leq a[j].end < a[k].start
a[i].end<a[j].start≤a[j].end<a[k].start

产生了矛盾！这说明假设是不成立的。因此，所有能够合并的区间都必然是连续的。

class Solution {
    public int[][] merge(int[][] intervals) {
        List<int[]> res = new ArrayList<>();
        if (intervals.length == 0 || intervals == null) return res.toArray(new int[0][]);
        // 对起点终点进行排序
        Arrays.sort(intervals, (a, b) -> a[0] - b[0]);
        int i = 0;
        while (i < intervals.length) {
            int left = intervals[i][0];
            int right = intervals[i][1];
            // 如果有重叠，循环判断哪个起点满足条件
            while (i < intervals.length - 1 && intervals[i + 1][0] <= right) {
                i++;
                right = Math.max(right, intervals[i][1]);
            }
            // 将现在的区间放进res里面
            res.add(new int[]{left, right});
            // 接着判断下一个区间
            i++;
        }
        return res.toArray(new int[0][]);
    }
}

复杂度分析

时间复杂度：O(nlogn)，其中 n 为区间的数量。除去排序的开销，我们只需要一次线性扫描，所以主要的时间开销是排序的 O(nlogn)。

空间复杂度：O(logn)，其中 nn 为区间的数量。这里计算的是存储答案之外，使用的额外空间。O(logn) 即为排序所需要的空间复杂度。

原题地址：

https://leetcode-cn.com/problems/merge-intervals/solution/he-bing-qu-jian-by-leetcode-solution/

猜你喜欢