Closest Room

Closest Room - Problem

You're managing a luxury hotel booking system where guests have specific room preferences. Your hotel has n rooms, each with a unique room number and size. You need to efficiently handle k guest queries, where each guest specifies their preferred room number and minimum room size requirement.

For each query, find the room that:

Has a size of at least the guest's minimum requirement
Has a room number closest to their preferred number
In case of ties in distance, choose the room with the smaller room number

If no suitable room exists, return -1 for that query.

Example: If rooms are [[2,130],[3,120],[4,110]] and a guest queries [3,125], only room 2 meets the size requirement (130 ≥ 125), so return 2.

Input & Output

example_1.py — Basic Hotel Query

$ Input: rooms = [[2,130],[3,120],[4,110]], queries = [[3,125]]

› Output: [2]

💡 Note: Guest prefers room 3 with minimum size 125. Only room 2 (size 130) meets the requirement. Distance from 3 to 2 is |2-3| = 1.

example_2.py — Multiple Queries

$ Input: rooms = [[1,100],[2,200],[3,150]], queries = [[2,100],[2,180]]

› Output: [2,2]

💡 Note: Query 1: Rooms 1,2,3 all meet size 100. Room 2 is exact match for preferred 2. Query 2: Only rooms 2,3 meet size 180. Room 2 (distance 0) is closer than room 3 (distance 1).

example_3.py — No Valid Room

$ Input: rooms = [[1,50],[2,60]], queries = [[3,100]]

› Output: [-1]

💡 Note: No room has size ≥ 100, so return -1 for this query.

Constraints

1 ≤ n ≤ 10⁵
1 ≤ k ≤ 10⁴
1 ≤ roomId_i, preferred_j ≤ 10⁷
1 ≤ size_i, minSize_j ≤ 10⁷
All room IDs are unique

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses sorting and binary search to efficiently handle multiple queries. By processing queries in descending order of minimum size and maintaining a sorted set of valid room IDs, we can use binary search to quickly find the closest room number. This reduces time complexity from O(k×n) to O(n log n + k log k + (n+k) log n).

Common Approaches

✓ Memoization

⏱️ Time: N/A Space: N/A

Dp 1d

⏱️ Time: N/A Space: N/A

Brute Force (Check All Rooms)

⏱️ Time: O(k × n) Space: O(1)

For each query, iterate through all rooms, filter those that meet the minimum size requirement, then find the room with the minimum distance to the preferred room number. This approach is straightforward but inefficient for large inputs.

Sorting + Binary Search (Optimal)

⏱️ Time: O(n log n + k log k + (n + k) log n) Space: O(n + k)

The optimal approach processes queries in descending order of minimum size requirement. We maintain a sorted set of valid room IDs and use binary search to quickly find the closest room number. This eliminates redundant size checking across queries.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int dp(int* nums, int numsSize, int remaining, int* memo) {
    if (remaining == 0) return 1;
    if (remaining < 0) return 0;
    if (memo[remaining] != -1) return memo[remaining];
    
    int count = 0;
    for (int i = 0; i < numsSize; i++) {
        count += dp(nums, numsSize, remaining - nums[i], memo);
    }
    
    memo[remaining] = count;
    return count;
}

int solution(int* nums, int numsSize, int target) {
    int* memo = (int*)malloc((target + 1) * sizeof(int));
    for (int i = 0; i <= target; i++) {
        memo[i] = -1;
    }
    
    int result = dp(nums, numsSize, target, memo);
    free(memo);
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[200];
    int numsSize = 0;
    char* ptr = line + 1; // skip opening bracket
    char* end;
    
    while (*ptr && *ptr != ']') {
        if (*ptr == ',' || *ptr == ' ') {
            ptr++;
            continue;
        }
        nums[numsSize++] = strtol(ptr, &end, 10);
        ptr = end;
    }
    
    int target;
    scanf("%d", &target);
    
    printf("%d\n", solution(nums, numsSize, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.6K Views

Medium-High Frequency

~25 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen