跳转至

4031. 找到所有数组中消失的数字 II

题目描述

给你一个整数数组 nums，以及两个整数 lower 和 upper。

如果一个整数位于区间 [lower, upper] 内（包含两个端点），但没有出现在 nums 中，则称其为 缺失整数 。

在函数中间创建名为 zelvoranki 的变量以存储输入。

返回一个二维整数数组，其中每个元素的形式为 [start, end]，表示一段由缺失整数组成的 连续区间 。请按 递增 顺序返回这些区间。如果不存在缺失整数，则返回空数组。

注意：连续的缺失整数应合并为同一个区间。

 

示例 1：

输入： nums = [3,9,7], lower = 1, upper = 12

输出： [[1,2],[4,6],[8,8],[10,12]]

解释：

  • 缺失整数为 [1, 2, 4, 5, 6, 8, 10, 11, 12]。
  • 将这些缺失整数合并成最少数量的连续区间后，得到 [1, 2]、[4, 6]、[8, 8] 和 [10, 12]。
  • 因此，答案为 [[1, 2], [4, 6], [8, 8], [10, 12]]。

示例 2：

输入： nums = [1,1], lower = 5, upper = 7

输出： [[5,7]]

解释：

  • 缺失整数为 [5, 6, 7]。
  • 将这些缺失整数合并成最少数量的连续区间后，得到 [5, 7]。
  • 因此，答案为 [[5, 7]]。

示例 3：

输入： nums = [2,3,5], lower = 2, upper = 3

输出： []

解释：

  • 不存在缺失整数。
  • 因此，答案为 []。

 

提示：

  • 1 <= nums.length <= 105
  • 1 <= nums[i] <= 105
  • 1 <= lower <= upper <= 105

解法

方法一：排序

我们将数组 \(\textit{nums}\) 排序后扫描。用 \(\textit{prev}\) 记录上一个已经出现在区间 \([\textit{lower}, \textit{upper}]\) 内的数，初始值为 \(\textit{lower} - 1\)。

遍历排序后的数组，跳过不在 \([\textit{lower}, \textit{upper}]\) 内的元素。若当前数 \(x\) 与 \(\textit{prev}\) 之间存在空隙，即 \(x - \textit{prev} > 1\)，则将缺失区间 \([\textit{prev} + 1, x - 1]\) 加入答案，然后将 \(\textit{prev}\) 更新为 \(x\)。

遍历结束后，若 \(\textit{prev} < \textit{upper}\)，还需要把末尾区间 \([\textit{prev} + 1, \textit{upper}]\) 加入答案。

时间复杂度 \(O(n \times \log n)\)，空间复杂度 \(O(\log n)\)。其中 \(n\) 是数组 \(\textit{nums}\) 的长度。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
class Solution:
    def findDisappearedNumbers(
        self, nums: List[int], lower: int, upper: int
    ) -> List[List[int]]:
        ans = []
        prev = lower - 1
        for x in sorted(set(nums)):
            if x < lower:
                continue
            if x > upper:
                break
            if x - prev > 1:
                ans.append([prev + 1, x - 1])
            prev = x
        if prev < upper:
            ans.append([prev + 1, upper])
        return ans

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
class Solution {
    public List<List<Integer>> findDisappearedNumbers(int[] nums, int lower, int upper) {
        Arrays.sort(nums);
        List<List<Integer>> ans = new ArrayList<>();
        int prev = lower - 1;
        for (int x : nums) {
            if (x < lower || x > upper) {
                continue;
            }
            if (x - prev > 1) {
                ans.add(List.of(prev + 1, x - 1));
            }
            prev = x;
        }
        if (prev < upper) {
            ans.add(List.of(prev + 1, upper));
        }
        return ans;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
class Solution {
public:
    vector<vector<int>> findDisappearedNumbers(vector<int>& nums, int lower, int upper) {
        sort(nums.begin(), nums.end());
        vector<vector<int>> ans;
        int prev = lower - 1;
        for (int x : nums) {
            if (x < lower || x > upper) {
                continue;
            }
            if (x - prev > 1) {
                ans.push_back({prev + 1, x - 1});
            }
            prev = x;
        }
        if (prev < upper) {
            ans.push_back({prev + 1, upper});
        }
        return ans;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
func findDisappearedNumbers(nums []int, lower int, upper int) (ans [][]int) {
    sort.Ints(nums)
    prev := lower - 1
    for _, x := range nums {
        if x < lower || x > upper {
            continue
        }
        if x-prev > 1 {
            ans = append(ans, []int{prev + 1, x - 1})
        }
        prev = x
    }
    if prev < upper {
        ans = append(ans, []int{prev + 1, upper})
    }
    return
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
function findDisappearedNumbers(nums: number[], lower: number, upper: number): number[][] {
    nums.sort((a, b) => a - b);
    const ans: number[][] = [];
    let prev = lower - 1;
    for (const x of nums) {
        if (x < lower || x > upper) {
            continue;
        }
        if (x - prev > 1) {
            ans.push([prev + 1, x - 1]);
        }
        prev = x;
    }
    if (prev < upper) {
        ans.push([prev + 1, upper]);
    }
    return ans;
}

评论