Keys and Rooms

Keys and Rooms - Problem

There are n rooms labeled from 0 to n - 1 and all the rooms are locked except for room 0. Your goal is to visit all the rooms.

However, you cannot enter a locked room without having its key. When you visit a room, you may find a set of distinct keys in it. Each key has a number on it, denoting which room it unlocks, and you can take all of them with you to unlock the other rooms.

Given an array rooms where rooms[i] is the set of keys that you can obtain if you visited room i, return true if you can visit all the rooms, or false otherwise.

Input & Output

Example 1 — Linear Chain

$ Input: rooms = [[1],[2],[3],[]]

› Output: true

💡 Note: Start at room 0 → get key 1 → visit room 1 → get key 2 → visit room 2 → get key 3 → visit room 3. All rooms visited.

Example 2 — Disconnected Rooms

$ Input: rooms = [[1,3],[3,0,1],[2],[0]]

› Output: false

💡 Note: From room 0, we can reach rooms 1 and 3. From room 1, we can't reach room 2 because we don't have key 2. Room 2 remains unreachable.

Example 3 — Single Room

$ Input: rooms = [[]]

› Output: true

💡 Note: Only one room exists (room 0) and we start there, so all rooms are visited.

Constraints

n == rooms.length
2 ≤ n ≤ 1000
0 ≤ rooms[i].length ≤ 1000
1 ≤ sum(rooms[i].length) ≤ 3000
0 ≤ rooms[i][j] < n
All the values of rooms[i] are unique

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 12 G Google 8 f Facebook 6

The key insight is that this is a graph connectivity problem where rooms are nodes and keys represent edges. Use DFS or BFS to traverse from room 0 and check if all rooms are reachable. Best approach is DFS with Time: O(n + k), Space: O(n).

Common Approaches

✓ Frequency Count

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

Heap

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

Breadth-First Search (BFS)

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

Use a queue to perform breadth-first search starting from room 0. Process rooms level by level, collecting keys and adding newly accessible rooms to the queue. This iterative approach avoids recursion stack issues.

Brute Force - Try All Combinations

⏱️ Time: O(n! × n²) Space: O(n)

Generate all possible permutations of room visits and check if any sequence allows visiting all rooms. This approach is extremely inefficient but conceptually straightforward.

Depth-First Search (DFS)

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

Start from room 0 and use depth-first search to visit all reachable rooms. Keep track of visited rooms and collect keys along the way. This is the optimal solution with linear time complexity.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int solution(int* arr, int arrSize, int k) {
    // Use hash map approach with separate arrays
    int values[10000];
    int counts[10000];
    int uniqueCount = 0;
    
    // Count frequencies
    for (int i = 0; i < arrSize; i++) {
        int found = 0;
        for (int j = 0; j < uniqueCount; j++) {
            if (values[j] == arr[i]) {
                counts[j]++;
                found = 1;
                break;
            }
        }
        if (!found) {
            values[uniqueCount] = arr[i];
            counts[uniqueCount] = 1;
            uniqueCount++;
        }
    }
    
    // Sort frequencies
    qsort(counts, uniqueCount, sizeof(int), compare);
    
    int removals = 0;
    int uniqueRemoved = 0;
    
    // Greedily remove elements with lowest frequency first
    for (int i = 0; i < uniqueCount; i++) {
        if (removals + counts[i] <= k) {
            removals += counts[i];
            uniqueRemoved++;
        } else {
            break;
        }
    }
    
    return uniqueCount - uniqueRemoved;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array properly  
    int arr[1000];
    int arrSize = 0;
    
    // Remove newline from fgets
    line[strcspn(line, "\n")] = 0;
    
    // Find start of numbers (skip '[')
    char* ptr = strchr(line, '[');
    if (ptr) ptr++;
    
    // Parse numbers separated by commas
    char* token = strtok(ptr, ",]");
    while (token != NULL && arrSize < 1000) {
        // Skip whitespace
        while (*token == ' ') token++;
        if (*token != '\0') {
            arr[arrSize++] = atoi(token);
        }
        token = strtok(NULL, ",]");
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", solution(arr, arrSize, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

125.0K Views

Medium Frequency

~15 min Avg. Time

2.8K 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