题目描述
给你一个二维整数数组 ranges ，其中 ranges[i] = [starti, endi] 表示 starti 到 endi 之间（包括二者）的所有整数都包含在第 i 个区间中。
你需要将 ranges 分成 两个 组（可以为空），满足：
- 每个区间只属于一个组。
- 两个有 交集 的区间必须在 同一个 组内。
如果两个区间有至少 一个 公共整数，那么这两个区间是 有交集 的。
- 比方说，区间
[1, 3] 和 [2, 5] 有交集，因为 2 和 3 在两个区间中都被包含。
请你返回将 ranges 划分成两个组的 总方案数 。由于答案可能很大，将它对 109 + 7 取余 后返回。
示例 1：
输入：ranges = [[6,10],[5,15]]
输出：2
解释：
两个区间有交集，所以它们必须在同一个组内。
所以有两种方案：
- 将两个区间都放在第 1 个组中。
- 将两个区间都放在第 2 个组中。
示例 2：
输入：ranges = [[1,3],[10,20],[2,5],[4,8]]
输出：4
解释：
区间 [1,3] 和 [2,5] 有交集，所以它们必须在同一个组中。
同理，区间 [2,5] 和 [4,8] 也有交集，所以它们也必须在同一个组中。
所以总共有 4 种分组方案：
- 所有区间都在第 1 组。
- 所有区间都在第 2 组。
- 区间 [1,3] ，[2,5] 和 [4,8] 在第 1 个组中，[10,20] 在第 2 个组中。
- 区间 [1,3] ，[2,5] 和 [4,8] 在第 2 个组中，[10,20] 在第 1 个组中。
提示：
1 <= ranges.length <= 105ranges[i].length == 20 <= starti <= endi <= 109
解法
方法一：排序 + 计数 + 快速幂
我们可以先对区间进行排序，相交的区间进行合并，统计有多少个不相交的区间，记为 $cnt$。
每个不相交的区间可以选择放在第一组或第二组，所以方案数为 $2^{cnt}$。注意到 $2^{cnt}$ 可能很大，所以需要对 $10^9 + 7$ 取模。这里可以使用快速幂求解。
时间复杂度 $O(n \times \log n)$，空间复杂度 $O(\log n)$。其中 $n$ 为区间个数。
我们也可以不使用快速幂，一旦发现有新的不相交的区间，就将方案数乘 $2$ 后对 $10^9 + 7$ 取模。
| class Solution:
def countWays(self, ranges: List[List[int]]) -> int:
ranges.sort()
cnt, mx = 0, -1
for start, end in ranges:
if start > mx:
cnt += 1
mx = max(mx, end)
mod = 10**9 + 7
return pow(2, cnt, mod)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 | class Solution {
public int countWays(int[][] ranges) {
Arrays.sort(ranges, (a, b) -> a[0] - b[0]);
int cnt = 0, mx = -1;
for (int[] e : ranges) {
if (e[0] > mx) {
++cnt;
}
mx = Math.max(mx, e[1]);
}
return qpow(2, cnt, (int) 1e9 + 7);
}
private int qpow(long a, int n, int mod) {
long ans = 1;
for (; n > 0; n >>= 1) {
if ((n & 1) == 1) {
ans = ans * a % mod;
}
a = a * a % mod;
}
return (int) ans;
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 | class Solution {
public:
int countWays(vector<vector<int>>& ranges) {
sort(ranges.begin(), ranges.end());
int cnt = 0, mx = -1;
for (auto& e : ranges) {
cnt += e[0] > mx;
mx = max(mx, e[1]);
}
using ll = long long;
auto qpow = [&](ll a, int n, int mod) {
ll ans = 1;
for (; n; n >>= 1) {
if (n & 1) {
ans = ans * a % mod;
}
a = a * a % mod;
}
return ans;
};
return qpow(2, cnt, 1e9 + 7);
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 | func countWays(ranges [][]int) int {
sort.Slice(ranges, func(i, j int) bool { return ranges[i][0] < ranges[j][0] })
cnt, mx := 0, -1
for _, e := range ranges {
if e[0] > mx {
cnt++
}
if mx < e[1] {
mx = e[1]
}
}
qpow := func(a, n, mod int) int {
ans := 1
for ; n > 0; n >>= 1 {
if n&1 == 1 {
ans = ans * a % mod
}
a = a * a % mod
}
return ans
}
return qpow(2, cnt, 1e9+7)
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13 | function countWays(ranges: number[][]): number {
ranges.sort((a, b) => a[0] - b[0]);
let mx = -1;
let ans = 1;
const mod = 10 ** 9 + 7;
for (const [start, end] of ranges) {
if (start > mx) {
ans = (ans * 2) % mod;
}
mx = Math.max(mx, end);
}
return ans;
}
|
方法二
| class Solution:
def countWays(self, ranges: List[List[int]]) -> int:
ranges.sort()
mx = -1
mod = 10**9 + 7
ans = 1
for start, end in ranges:
if start > mx:
ans = ans * 2 % mod
mx = max(mx, end)
return ans
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 | class Solution {
public int countWays(int[][] ranges) {
Arrays.sort(ranges, (a, b) -> a[0] - b[0]);
int mx = -1;
int ans = 1;
final int mod = (int) 1e9 + 7;
for (int[] e : ranges) {
if (e[0] > mx) {
ans = ans * 2 % mod;
}
mx = Math.max(mx, e[1]);
}
return ans;
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 | class Solution {
public:
int countWays(vector<vector<int>>& ranges) {
sort(ranges.begin(), ranges.end());
int ans = 1, mx = -1;
const int mod = 1e9 + 7;
for (auto& e : ranges) {
if (e[0] > mx) {
ans = ans * 2 % mod;
}
mx = max(mx, e[1]);
}
return ans;
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14 | func countWays(ranges [][]int) int {
sort.Slice(ranges, func(i, j int) bool { return ranges[i][0] < ranges[j][0] })
ans, mx := 1, -1
const mod = 1e9 + 7
for _, e := range ranges {
if e[0] > mx {
ans = ans * 2 % mod
}
if mx < e[1] {
mx = e[1]
}
}
return ans
}
|