【每日一题】1851. 包含每个查询的最小区间

**每日一题**

**题目描述**

给定一个数组 `queries`，其中每个元素都是一个整数对 `[left, right]`。要求找到包含每个查询的最小区间。

**输入**

* `n`: 整数，表示 `queries` 中的元素数量。
* `queries`: 数组，每个元素都是一个整数对 `[left, right]`。

**输出**

* `intervals`: 数组，每个元素都是一个整数对 `[min_left, min_right]`，其中 `min_left` 和 `min_right` 是包含每个查询的最小区间。

**示例1**

输入：`n =3`, `queries = [[1,2],[2,3],[4,5]]`
输出：`[[1,5]]`

**示例2**

输入：`n =4`, `queries = [[6,7],[8,9],[10,11],[12,13]]`
输出：`[[6,13]]`

**示例3**

输入：`n =5`, `queries = [[1,2],[3,4],[5,6],[7,8],[9,10]]`
输出：`[[1,10]]`

**解决方案**

我们可以使用一个大小为 `n` 的哈希表来存储每个查询的最小左边界和最大右边界。然后，我们可以遍历这个哈希表，找到包含每个查询的最小区间。

class Solution:
 def minInterval(self, intervals: List[List[int]], n: int) -> List[List[int]]:
 # 将所有左边界和右边界存储在一个列表中 lefts = []
 rights = []
 for left, right in intervals:
 lefts.append(left)
 rights.append(right)

 # 对左边界和右边界进行排序 lefts.sort()
 rights.sort()

 # 初始化哈希表 min_left = [float('inf')] * n max_right = [-1] * n # 遍历左边界和右边界，更新哈希表 for i, (left, right) in enumerate(zip(lefts, rights)):
 j = bisect.bisect_left(lefts, left)
 min_left[j] = min(min_left[j], left)
 max_right[j] = max(max_right[j], right)

 # 初始化结果列表 intervals = []

 # 遍历哈希表，找到包含每个查询的最小区间 for i in range(n):
 j = bisect.bisect_left(lefts, min_left[i])
 k = bisect.bisect_right(rights, max_right[i])
 if j <= k:
 intervals.append([min_left[i], max_right[i]])

 return intervals

**注释**

* 我们首先将所有左边界和右边界存储在两个列表中。
* 然后，我们对这些列表进行排序，以便于后续的遍历。
* 初始化哈希表 `min_left` 和 `max_right`，其中 `min_left[i]` 表示包含第 `i` 个查询的最小左边界，而 `max_right[i]` 表示包含第 `i` 个查询的最大右边界。
* 遍历左边界和右边界，更新哈希表中的值。
* 初始化结果列表 `intervals`。
* 遍历哈希表，找到包含每个查询的最小区间，并将其添加到结果列表中。

**时间复杂度**

* 将所有左边界和右边界存储在两个列表中：O(n)
* 对这些列表进行排序：O(n log n)
* 初始化哈希表：O(n)
* 遍历左边界和右边界，更新哈希表：O(n)
* 遍历哈希表，找到包含每个查询的最小区间：O(n)

总时间复杂度为 O(n) + O(n log n) + O(n) + O(n) = O(n log n)

**空间复杂度**

* 需要额外的空间来存储左边界和右边界：O(n)
* 需要额外的空间来存储哈希表：O(n)
* 需要额外的空间来存储结果列表：O(n)

总空间复杂度为 O(n) + O(n) + O(n) = O(n)