1847.最近的房间

【LetMeFly】1847.最近的房间：有序集合

力扣题目链接：https://leetcode.cn/problems/closest-room/

一个酒店里有 n 个房间，这些房间用二维整数数组 rooms 表示，其中 rooms[i] = [roomIdi, sizei] 表示有一个房间号为 roomIdi 的房间且它的面积为 sizei 。每一个房间号 roomIdi 保证是 独一无二 的。

同时给你 k 个查询，用二维数组 queries 表示，其中 queries[j] = [preferredj, minSizej] 。第 j 个查询的答案是满足如下条件的房间 id ：

  • 房间的面积 至少 为 minSizej ，且
  • abs(id - preferredj) 的值 最小 ，其中 abs(x) 是 x 的绝对值。

如果差的绝对值有 相等 的，选择 最小 的 id 。如果 没有满足条件的房间 ，答案为 -1 。

请你返回长度为 k 的数组 answer ，其中 answer[j] 为第 j 个查询的结果。

 

示例 1：

输入：rooms = [[2,2],[1,2],[3,2]], queries = [[3,1],[3,3],[5,2]]
输出：[3,-1,3]
解释：查询的答案如下：
查询 [3,1] ：房间 3 的面积为 2 ，大于等于 1 ，且号码是最接近 3 的，为 abs(3 - 3) = 0 ，所以答案为 3 。
查询 [3,3] ：没有房间的面积至少为 3 ，所以答案为 -1 。
查询 [5,2] ：房间 3 的面积为 2 ，大于等于 2 ，且号码是最接近 5 的，为 abs(3 - 5) = 2 ，所以答案为 3 。

示例 2：

输入：rooms = [[1,4],[2,3],[3,5],[4,1],[5,2]], queries = [[2,3],[2,4],[2,5]]
输出：[2,1,3]
解释：查询的答案如下：
查询 [2,3] ：房间 2 的面积为 3 ，大于等于 3 ，且号码是最接近的，为 abs(2 - 2) = 0 ，所以答案为 2 。
查询 [2,4] ：房间 1 和 3 的面积都至少为 4 ，答案为 1 因为它房间编号更小。
查询 [2,5] ：房间 3 是唯一面积大于等于 5 的，所以答案为 3 。

 

提示：

  • n == rooms.length
  • 1 <= n <= 105
  • k == queries.length
  • 1 <= k <= 104
  • 1 <= roomIdi, preferredj <= 107
  • 1 <= sizei, minSizej <= 107

解题方法：有序集合

我们可以首先对所有的查询按照“size从大到小”的顺序排序，同时保留原本的顺序信息(得知道一个查询是原来的第几个查询)。

这样做有什么好处呢？排序后满足前一个查询的size的房间一定能满足后一个查询。

因此我们可以对房间依据size从大到小的顺序排序，使用一个指针指向所有已经满足size条件的room，并将所有满足size条件的roomId添加到有序集合roomIds中。

也就是说，对于一个查询，roomIds中的房间都可以住。问题就变成了如何在一个有序集合里查询与queryId最接近的值，直接使用二分查找即可。

  • 时间复杂度$O((n+k)\log n+k\log k)$。排序$O(n\log n+k\log k)$，单次添加到有序集合$O(\log n)$一共添加最多$n$次，单次查询$O(\log n)$一共查询$k$次。
  • 空间复杂度$O(n+ k)$

AC代码

C++

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class Solution {
public:
    vector<int> closestRoom(vector<vector<int>>& rooms, vector<vector<int>>& queries) {
        vector<int> queryIdx(queries.size());
        iota(queryIdx.begin(), queryIdx.end(), 0);
        sort(queryIdx.begin(), queryIdx.end(), [&](int i, int j) {
            return queries[i][1] > queries[j][1];
        });
        sort(rooms.begin(), rooms.end(), [](vector<int>& a, vector<int>& b) {
            return a[1] > b[1];
        });
        set<int> canIds;
        vector<int> ans(queries.size());
        for (int locR = 0, locQ = 0; locQ < queryIdx.size(); locQ++) {
            int queryId = queries[queryIdx[locQ]][0], size = queries[queryIdx[locQ]][1];
            while (locR < rooms.size() && rooms[locR][1] >= size) {
                canIds.insert(rooms[locR++][0]);
            }
            if (canIds.empty()) {
                ans[queryIdx[locQ]] = -1;
                continue;
            }
            set<int>::iterator it = canIds.lower_bound(queryId);
            int idDiff = abs(queryId - *it);
            if (it != canIds.begin() && abs(queryId - *prev(it)) <= idDiff) {
                it--;
            }
            ans[queryIdx[locQ]] = *it;
        }
        return ans;
    }
};

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
from typing import List
from sortedcontainers import SortedList
from bisect import bisect_left

class Solution:
    def closestRoom(self, rooms: List[List[int]], queries: List[List[int]]) -> List[int]:
        queryIdx = [i for i in range(len(queries))]
        queryIdx.sort(key=lambda x: -queries[x][1])
        rooms.sort(key=lambda x: -x[1])
        canIds = SortedList()
        ans = [-1] * len(queries)
        locR = 0
        for locQI in range(len(queries)):
            queryId, querySize = queries[queryIdx[locQI]]
            while locR < len(rooms) and rooms[locR][1] >= querySize:
                canIds.add(rooms[locR][0])
                locR += 1
            if not canIds:
                continue
            it = bisect_left(canIds, queryId)
            # print(f'bisect_left({canIds, queryId}) = {it}')  # bisect_left((SortedList([1, 2, 3]), 5)) = 3
            if it == len(canIds) or (it and abs(canIds[it - 1] - queryId) <= abs(canIds[it] - queryId)):
                it -= 1
            ans[queryIdx[locQI]] = canIds[it]
        return ans

Java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import java.util.TreeSet;
import java.util.Arrays;

class Solution {
    public int[] closestRoom(int[][] rooms, int[][] queries) {
        Integer[] queryIdx = new Integer[queries.length];  // int的话不支持sort的Comparator
        Arrays.setAll(queryIdx, i -> i);
        Arrays.sort(queryIdx, (i, j) -> queries[j][1] - queries[i][1]);
        Arrays.sort(rooms, (a, b) -> b[1] - a[1]);
        TreeSet<Integer> canIds = new TreeSet<>();
        int[] ans = new int[queries.length];
        int locR = 0;
        for (int locQI = 0; locQI < queryIdx.length; locQI++) {
            int queryId = queries[queryIdx[locQI]][0], querySize = queries[queryIdx[locQI]][1];
            while (locR < rooms.length && rooms[locR][1] >= querySize) {
                canIds.add(rooms[locR++][0]);
            }
            if (canIds.isEmpty()) {
                ans[queryIdx[locQI]] = -1;
                continue;
            }
            Integer floor = canIds.floor(queryId);
            Integer ceil = canIds.ceiling(queryId);
            if (floor == null) {
                ans[queryIdx[locQI]] = ceil;
            } else if (ceil == null) {
                ans[queryIdx[locQI]] = floor;
            } else {
                if (Math.abs(floor - queryId) <= Math.abs(ceil - queryId)) {
                    ans[queryIdx[locQI]] = floor;
                } else {
                    ans[queryIdx[locQI]] = ceil;
                }
            }
        }
        return ans;
    }
}

同步发文于CSDN和我的个人博客，原创不易，转载经作者同意后请附上原文链接哦~

Tisfy：https://letmefly.blog.csdn.net/article/details/144524587

#题解 #数组 #排序 #LeetCode #困难 #二分查找 #有序集合
1847.最近的房间
https://blog.letmefly.xyz/2024/12/17/LeetCode 1847.最近的房间/
作者
Tisfy
发布于
2024年12月17日
许可协议