第310场周赛 NO3 将区间分为最少组数

题目描述：

给你一个二维整数数组 intervals ，其中 intervals[i] = [lefti, righti] 表示 闭 区间 [lefti, righti] 。

你需要将 intervals 划分为一个或者多个区间 组 ，每个区间 只 属于一个组，且同一个组中任意两个区间 不相交 。

请你返回 最少 需要划分成多少个组。

如果两个区间覆盖的范围有重叠（即至少有一个公共数字），那么我们称这两个区间是 相交 的。比方说区间 [1, 5] 和 [5, 8] 相交。

Level	AC rate
Medium	41.3%

---

题目解析（差分）：

最少需要几组只需要计算数组区间重叠的最大值即可，我们首先根据数值范围来进行先扫描来判断重叠数组最大值为多少代码如下：

// 线扫描 差分数组
class Solution {
    public int minGroups(int[][] intervals) {
        int ans = 0;
        for(int i = 1 ; i<=1000000 ; i++){
            int temp = 0;
            for(int j = 0 ; j<intervals.length ; j++){
                if(intervals[j][0]<=i&&intervals[j][1]>=i)temp++;
            }
            ans = Math.max(ans,temp);
        }
        return ans;
    }
}

出现了超时的问题，然后我们通过一个覆盖数值范围的数组，然后根据所给的数组来使得对应位置加一即可，最终遍历整个数组判断最大值，代码如下：

// 差分
class Solution {
    public int minGroups(int[][] intervals) {
        int[] pos = new int[1000000];
        int ans = 0;
        for(int i = 0 ; i<intervals.length ; i++){
            for(int j = intervals[i][0] ; j<=intervals[i][1] ; j++){
                pos[j]++;
                ans = Math.max(ans,pos[j]);
            }
        }
        return ans;
    }
}

还是出现了超时的问题，然后我们还是通过一个覆盖数值范围的数组，只不过这次我们不再去遍历整个区间，而是我们将区间起点对应的位置加1，终点后一个位置减1，某个点的重叠区间值为前面所有的数值加起来即可，代码如下：

// 差分
class Solution {
    public int minGroups(int[][] intervals) {
        int ans = 0;
        int[] pos = new int[1000001];
        for(int i = 0 ; i<intervals.length ; i++){
            pos[intervals[i][0]-1]++;
            pos[intervals[i][1]]--;
        }
        int temp = 0;
        for(int i = 0 ; i<pos.length ; i++){
            temp += pos[i];
            ans = Math.max(ans,temp);
        }
        return ans;
    }
}

执行用时：53 ms, 在所有 Java 提交中击败了90.40%的用户

内存消耗：91.3 MB, 在所有 Java 提交中击败了18.45%的用户

题目解析（贪心算法）：

如果一个数组的起点大于目前所有组最小的终点，那么就将该区间合并到对应的最小终点的区间中并更新区间的终点，否则就以该区间新开一组，最后有多少组就是至少需要的组数，这里用到了小根堆了对最小终点进行的维护和方便存取，代码如下：

// 贪心算法
class Solution {
    public int minGroups(int[][] intervals) {
        int ans = 1;
        Arrays.sort(intervals,(a,b)->a[0]-b[0]);
        PriorityQueue <Integer> queue = new PriorityQueue<Integer>();
        queue.offer(intervals[0][1]);
        for(int i = 1 ; i<intervals.length ; i++){
            int temp = queue.poll();
            if(temp<intervals[i][0])queue.offer(intervals[i][1]);
            else{
                queue.offer(temp);
                queue.offer(intervals[i][1]);
                ans++;
            }
        }
        return ans;
    }
}

执行用时：139 ms, 在所有 Java 提交中击败了23.58%的用户

内存消耗：84.8 MB, 在所有 Java 提交中击败了51.34%的用户