题目：
一个酒店里有 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.length1 <= n <= 105k == queries.length1 <= k <= 1041 <= roomIdi, preferredj <= 1071 <= sizei, minSizej <= 107
思路：
核心思路
把询问排序，通过改变回答询问的顺序，使问题更容易处理。
比如有两个询问，其中 minSize 分别为 3 和 6。
我们可以先回答 minSize = 6 的询问，再回答 minSize = 3 的询问。
也就是先把面积 ≥ 6 的房间号添加到一个有序集合中，回答 minSize = 6 的询问；然后把面积 ≥ 3 的房间号添加到有序集合中，回答 minSize = 3 的询问。
这里的关键是，由于面积 ≥ 6 的房间编号已经添加到有序集合中了，所以后续只需把面积在 [3, 5] 中的房间号添加到有序集合中，不需要重复处理面积 ≥ 6 的房间。
具体思路
直接对 queries 排序是不行的，因为返回的答案必须按照询问的顺序。
解决办法：设 q 是 queries 的长度，创建一个下标数组 queryIds=[0,1,2,…,q−1]，把下标根据 queries 的 minSize 从大到小排序，这样就避免直接对 queries 排序了。
把 rooms 按照 size 从小到大排序（也可以从大到小）。
然后创建一个有序集合 roomIds。用双指针遍历 queryIds 和 rooms，把房间面积 ≥ minSize 的房间号添加到 roomIds 中。然后在 roomIds 中搜索离 preferred 最近的左右两个房间号，其中离 preferred 最近的房间号就是答案。
代码：
class Solution {
public:
vector<int> closestRoom(vector<vector<int>>& rooms, vector<vector<int>>& queries) {
// 按照 size 从大到小排序
ranges::sort(rooms, {}, [](auto& a) { return -a[1]; });
int q = queries.size();
vector<int> query_ids(q);
iota(query_ids.begin(), query_ids.end(), 0);
// 按照 minSize 从大到小排序
ranges::sort(query_ids, {}, [&](int i) { return -queries[i][1]; });
vector<int> ans(q, -1);
set<int> room_ids; // 自动从小到大排序
int j = 0;
for (int i : query_ids) {
int preferred_id = queries[i][0], min_size = queries[i][1];
while (j < rooms.size() && rooms[j][1] >= min_size) {
room_ids.insert(rooms[j][0]);
j++;
}
int diff = INT_MAX;
auto it = room_ids.lower_bound(preferred_id);
if (it != room_ids.begin()) {
auto p = prev(it);
diff = preferred_id - *p; // 左边的差
ans[i] = *p;
}
if (it != room_ids.end() && *it - preferred_id < diff) { // 右边的差更小
ans[i] = *it;
}
}
return ans;
}
};