Closest Room solution and explanation

from sortedcontainers import SortedList

def closestRoom(rooms, queries):
    # Sort rooms by size, descending
    rooms.sort(key=lambda x: -x[1])
    queries = [(p, s, i) for i, (p, s) in enumerate(queries)]
    # Sort queries by minSize, descending
    queries.sort(key=lambda x: -x[1])
    # Result array
    answer = [-1] * len(queries)
    # SortedList for room IDs
    ids = SortedList()
    j = 0
    # Iterate over each query
    for preferred, minSize, index in queries:
        # Add all rooms that meet the quota size
        while j < len(rooms) and rooms[j][1] >= minSize:
            ids.add(rooms[j][0])
            j += 1
        # Find the nearest id
        if ids:
            pos = ids.bisect_left(preferred)
            candidates = []
            if pos < len(ids): candidates.append(ids[pos])
            if pos > 0: candidates.append(ids[pos - 1])
            # Determine closest
            if candidates:
                answer[index] = min(candidates, key=lambda x: (abs(x - preferred), x))
    return answer

import java.util.*;

class Solution {
    public int[] closestRoom(int[][] rooms, int[][] queries) {
        Arrays.sort(rooms, (a, b) -> b[1] - a[1]);  // Sort rooms by size desc.
        int qLen = queries.length;
        int[] answer = new int[qLen];
        int[][] queriesWithIndex = new int[qLen][3];
        // Storing queries with original index
        for (int i = 0; i < qLen; i++) {
            queriesWithIndex[i][0] = queries[i][0];
            queriesWithIndex[i][1] = queries[i][1];
            queriesWithIndex[i][2] = i;
        }
        Arrays.sort(queriesWithIndex, (a, b) -> b[1] - a[1]); // Sort by minSize desc.
        TreeSet<Integer> availableRooms = new TreeSet<>();
        int j = 0;
        for (int[] query : queriesWithIndex) {
            int preferred = query[0], minSize = query[1], index = query[2];
            while (j < rooms.length && rooms[j][1] >= minSize) {
                availableRooms.add(rooms[j][0]);
                j++;
            }
            Integer floor = availableRooms.floor(preferred);
            Integer ceil = availableRooms.ceiling(preferred);
            if (floor == null && ceil == null) {
                answer[index] = -1;
            } else if (floor == null) {
                answer[index] = ceil;
            } else if (ceil == null) {
                answer[index] = floor;
            } else {
                answer[index] = (preferred - floor <= ceil - preferred) ? floor : ceil;
            }
        }
        return answer;
    }
}

#include <vector>
#include <algorithm>
#include <set>
#include <limits.h>

using namespace std;

class Solution {
public:
    vector<int> closestRoom(vector<vector<int>>& rooms, vector<vector<int>>& queries) {
        sort(rooms.begin(), rooms.end(), [](const vector<int>& a, const vector<int>& b) { return a[1] > b[1]; });
        vector<pair<pair<int, int>, int>> indexedQueries;
        for (int i = 0; i < queries.size(); ++i) {
            indexedQueries.push_back({{queries[i][0], queries[i][1]}, i});
        }
        sort(indexedQueries.begin(), indexedQueries.end(), [](const auto& a, const auto& b) { return a.first.second > b.first.second; });

        vector<int> result(queries.size(), -1);
        set<int> activeRooms;

        int j = 0;
        for (const auto& query : indexedQueries) {
            int preferred = query.first.first;
            int minSize = query.first.second;
            int idx = query.second;

            while (j < rooms.size() && rooms[j][1] >= minSize) {
                activeRooms.insert(rooms[j][0]);
                ++j;
            }

            if (activeRooms.empty()) continue;

            auto it = activeRooms.lower_bound(preferred);

            int closestRoom = INT_MAX;
            if (it != activeRooms.end()) {
                closestRoom = *it;
            }
            if (it != activeRooms.begin()) {
                --it;
                if (abs(*it - preferred) <= abs(closestRoom - preferred)) {
                    closestRoom = *it;
                }
            }

            result[idx] = closestRoom;
        }
        return result;
    }
};

function closestRoom(rooms, queries) {
    rooms.sort((a, b) => b[1] - a[1]);
    queries = queries.map((q, i) => [...q, i]);
    queries.sort((a, b) => b[1] - a[1]);
    const answer = Array(queries.length).fill(-1);
    const availableRooms = new Set();
    let j = 0;
    for (const [preferred, minSize, index] of queries) {
        while (j < rooms.length && rooms[j][1] >= minSize) {
            availableRooms.add(rooms[j][0]);
            j++;
        }
        if (availableRooms.size > 0) {
            let closestId = -1;
            let minDistance = Infinity;
            for (const id of availableRooms) {
                const distance = Math.abs(id - preferred);
                if (distance < minDistance || (distance === minDistance && id < closestId)) {
                    minDistance = distance;
                    closestId = id;
                }
            }
            answer[index] = closestId;
        }
    }
    return answer;
}

func closestRoom(rooms [][]int, queries [][]int) []int {
	n, k := len(rooms), len(queries)
	sort.Slice(rooms, func(i, j int) bool { return rooms[i][1] < rooms[j][1] })
	idx := make([]int, k)
	ans := make([]int, k)
	for i := range idx {
		idx[i] = i
		ans[i] = -1
	}
	sort.Slice(idx, func(i, j int) bool { return queries[idx[i]][1] < queries[idx[j]][1] })
	rbt := redblacktree.NewWithIntComparator()
	merge := func(rbt *redblacktree.Tree, key, value int) {
		if v, ok := rbt.Get(key); ok {
			nxt := v.(int) + value
			if nxt == 0 {
				rbt.Remove(key)
			} else {
				rbt.Put(key, nxt)
			}
		} else {
			rbt.Put(key, value)
		}
	}
	for _, room := range rooms {
		merge(rbt, room[0], 1)
	}
	i := 0

	for _, j := range idx {
		prefer, minSize := queries[j][0], queries[j][1]
		for i < n && rooms[i][1] < minSize {
			merge(rbt, rooms[i][0], -1)
			i++
		}
		if i == n {
			break
		}
		c, _ := rbt.Ceiling(prefer)
		f, _ := rbt.Floor(prefer)
		if c != nil {
			ans[j] = c.Key.(int)
		}
		if f != nil && (ans[j] == -1 || ans[j]-prefer >= prefer-f.Key.(int)) {
			ans[j] = f.Key.(int)
		}
	}
	return ans
}