LeetCode 1893. Check if All the Integers in a Range Are Covered【数组/差分】简单

You are given a 2D integer array ranges and two integers left and right. Each ranges[i] = [starti, endi] represents an inclusive interval between starti and endi.

Return true if each integer in the inclusive range [left, right] is covered by at least one interval in ranges. Return false otherwise.

An integer x is covered by an interval ranges[i] = [starti, endi] if starti <= x <= endi.

Example 1:

Input: ranges = [[1,2],[3,4],[5,6]], left = 2, right = 5
Output: true
Explanation: Every integer between 2 and 5 is covered:
- 2 is covered by the first range.
- 3 and 4 are covered by the second range.
- 5 is covered by the third range.

Example 2:

Input: ranges = [[1,10],[10,20]], left = 21, right = 21
Output: false
Explanation: 21 is not covered by any range.

Constraints:

• 1 <= ranges.length <= 50
• 1 <= starti <= endi <= 50
• 1 <= left <= right <= 50

题意：给你一个二维整数数组 ranges 和两个整数 left 和 right 。每个 ranges[i] = [starti, endi] 表示一个从 starti 到 endi 的 闭区间 。

如果闭区间 [left, right] 内每个整数都被 ranges 中 至少一个 区间覆盖，那么请你返回 true ，否则返回 false 。

已知区间 ranges[i] = [starti, endi] ，如果整数 x 满足 starti <= x <= endi ，那么我们称整数x 被覆盖了。

---

解法1 暴力

暴力枚举 [left, right] 区间内的每一个整数，看是否有区间覆盖了它：

class Solution {
public:
    bool isCovered(vector<vector<int>>& ranges, int left, int right) {
        for (int i = left; i <= right; ++i) {
            bool flag = false;
            for (const vector<int>& range : ranges) {
                if (i >= range[0] && i <= range[1]) {
                    flag = true; 
                    break;
                }
            }
            if (!flag) return false; //没有区间覆盖这一整数
        }
        return true;
    }
};

运行效率如下：

执行用时：4 ms, 在所有 C++ 提交中击败了89.49% 的用户
内存消耗：8.6 MB, 在所有 C++ 提交中击败了48.34% 的用户

时间复杂度为：$O((right-left+1)\times ranges.length)$ ，空间复杂度为：$O(1)$ 。

另一种暴力方法是，遍历所有的区间，将它们覆盖的点标记在数轴上，然后查看 [left, right] 这一区间是否全部被标记：

class Solution {
public:
    bool isCovered(vector<vector<int>>& ranges, int left, int right) {
        bitset<60> bst;
        for (const vector<int>& range : ranges)
            for (int i = range[0]; i <= range[1]; ++i) bst[i] = true;
        for (int i = left; i <= right; ++i) if (bst[i] == false) return false;
        return true;
    }
};

运行效率如下：

执行用时：8 ms, 在所有 C++ 提交中击败了42.04% 的用户
内存消耗：8.6 MB, 在所有 C++ 提交中击败了51.11% 的用户

时间复杂度为：$O(ranges.length\times {\sum }_{i=0}^{ranges.length-1}(en{d}_i-star{t}_i+1)+(right-left+1))$ ，空间复杂度为：$O(max(en{d}_i))$ 。不难发现，上一种暴力解法的优势更大。

---

解法2 差分

在第二种暴力做法上的优化，用空间换时间，用差分代替暴力标记：

class Solution {
public:
    bool isCovered(vector<vector<int>>& ranges, int left, int right) {
        vector<int> d(60, 0);
        for (const vector<int>& range : ranges) ++d[range[0]], --d[range[1] + 1];
        for (int i = 1; i < 60; ++i) d[i] += d[i - 1]; 
        for (int i = left; i <= right; ++i) if (d[i] <= 0) return false;
        return true;
    }
};

运行效率如下：

执行用时：0 ms, 在所有 C++ 提交中击败了100.00% 的用户
内存消耗：8.4 MB, 在所有 C++ 提交中击败了85.51% 的用户

时间复杂度为：$O(ranges.length+max(en{d}_i)+(right-left+1))$ ，空间复杂度为：$O(max(en{d}_i))$ 。