LeetCode 2406. 将区间分为最少组数

2406. 将区间分为最少组数

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

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

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

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

示例 1：

输入：intervals = [[5,10],[6,8],[1,5],[2,3],[1,10]]
输出：3
解释：我们可以将区间划分为如下的区间组：
- 第 1 组：[1, 5] ，[6, 8] 。
- 第 2 组：[2, 3] ，[5, 10] 。
- 第 3 组：[1, 10] 。
可以证明无法将区间划分为少于 3 个组。

示例 2：

输入：intervals = [[1,3],[5,6],[8,10],[11,13]]
输出：1
解释：所有区间互不相交，所以我们可以把它们全部放在一个组内。

提示：

• 1 <= intervals.length <= 10^5
• intervals[i].length == 2
• 1 <= lefti <= righti <= 10^6

---

提示 1

Can you find a different way to describe the question?

---

提示 2

The minimum number of groups we need is equivalent to the maximum number of intervals that overlap at some point. How can you find that?

解法：差分

根据提示2，可以使用差分数组来解本题。

关于差分数组的详细讲解：LeetCode 1094. 拼车-CSDN博客

本题思路可以转换成上下车模型，每个区间看成一个人，他在 left 时刻上车，right+1 时刻下车，最后答案为同时在车上的人数的最大值，这可以用差分数组实现，

这里 diff 数组的范围从 min(intervals[i][0]) 到 max(intervals[i][1]) ，这样可以减少遍历次数，并防止溢出。

Java版：

class Solution {
    public int minGroups(int[][] intervals) {
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
        for (int[] interval : intervals) {
            min = Math.min(min, interval[0]);
            max = Math.max(max, interval[1]);
        }
        int m = max - min + 1;
        int[] diff = new int[m];
        for (int[] interval : intervals) {
            int left = interval[0];
            int right = interval[1];
            diff[left - min]++;
            if (right - min + 1 < m) {
                diff[right - min + 1]--;
            }
        }
        int ans = diff[0];
        for (int i = 1; i < m; i++) {
            diff[i] += diff[i - 1];
            ans = Math.max(ans, diff[i]);
        }
        return ans;
    }
}

Python版：

class Solution:
    def minGroups(self, intervals: List[List[int]]) -> int:
        min_ = intervals[0][0]
        max_ = intervals[0][1]
        for l, r in intervals:
            min_ = min(min_, l)
            max_ = max(max_, r)
        m = max_ - min_ + 1
        diff = [0] * m
        for l, r in intervals:
            diff[l - min_] += 1
            if r - min_ + 1 < m:
                diff[r - min_ + 1] -= 1
        diff = list(accumulate(diff))
        return max(diff)

复杂度分析

• 时间复杂度：O(n+m)，其中 n 是数组 intervals 的长度，m 是 差分数组 diff 的长度。
• 空间复杂度：O(m)，即为差分数组 diff 需要使用的空间。

类似题型：

LeetCode 1109. 航班预订统计-CSDN博客

LeetCode 2381. 字母移位 II-CSDN博客