Keys and Rooms - Practice Coding Problems

Keys and Rooms - Problem

Imagine you're exploring a mysterious mansion with n rooms labeled from 0 to n-1. All rooms are locked except for room 0, which serves as your starting point. Your mission is to visit every single room in the mansion.

Here's the catch: you can only enter a locked room if you have its specific key! Fortunately, each room you visit might contain a set of keys that unlock other rooms. Each key has a number indicating which room it opens, and you can collect all the keys you find.

Input: An array rooms where rooms[i] contains all the keys you'll find in room i.

Output: Return true if you can visit all rooms, false otherwise.

Example: If rooms = [[1],[2],[3],[]], you start in room 0, find key 1, use it to enter room 1, find key 2, enter room 2, find key 3, enter room 3. All rooms visited → return true!

Input & Output

example_1.py — Basic Connected Graph

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

› Output: true

💡 Note: Start in room 0, get key 1 → visit room 1, get key 2 → visit room 2, get key 3 → visit room 3. All 4 rooms visited successfully.

example_2.py — Disconnected Graph

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

› Output: false

💡 Note: Start in room 0, can visit rooms 1 and 3, but room 2 is unreachable because no room we can access contains key 2.

example_3.py — Single Room

$ Input: rooms = [[]]

› Output: true

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

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

Understanding the Visualization

Model as Graph

Each room is a node, each key creates an edge to another room

Start DFS from Room 0

Begin traversal from the unlocked starting room

Follow Key Edges

For each key found, traverse to that room if not visited

Check Connectivity

All rooms visited means the graph is fully connected from room 0

Key Takeaway

🎯 Key Insight: This is a graph connectivity problem! Use DFS/BFS to explore all reachable rooms from the starting point.

Asked in

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

The optimal solution uses Depth-First Search (DFS) to treat this as a graph traversal problem. Starting from room 0, we systematically visit each accessible room exactly once, collecting keys and recursively exploring newly accessible rooms. This achieves O(n + k) time complexity where n is the number of rooms and k is the total number of keys.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Naive Exploration)	O(n²)	O(n)	Repeatedly scan all rooms until no new rooms can be visited
Depth-First Search (Optimal)	O(n + k)	O(n)	Use DFS to explore rooms systematically, visiting each room exactly once

Brute Force (Naive Exploration) — Algorithm Steps

Mark room 0 as visited and collect its keys
Repeat: scan all rooms and visit any unvisited room we have a key for
Continue until no new rooms can be visited
Check if all rooms were visited

Visualization

Tap to expand

Step-by-Step Walkthrough

Start in Room 0

Visit room 0 and collect all its keys

Scan All Rooms

Check every room to see if we can visit it with our current keys

Repeat Until Stuck

Keep scanning until no new rooms can be visited

Code -

solution.c — C

#include <stdbool.h>
#include <stdlib.h>

bool canVisitAllRooms(int** rooms, int roomsSize, int* roomsColSize) {
    bool* visited = calloc(roomsSize, sizeof(bool));
    bool* keys = calloc(roomsSize, sizeof(bool));
    
    // Start with room 0
    visited[0] = true;
    for (int i = 0; i < roomsColSize[0]; i++) {
        keys[rooms[0][i]] = true;
    }
    
    bool changed = true;
    while (changed) {
        changed = false;
        for (int i = 0; i < roomsSize; i++) {
            if (!visited[i] && keys[i]) {
                visited[i] = true;
                for (int j = 0; j < roomsColSize[i]; j++) {
                    keys[rooms[i][j]] = true;
                }
                changed = true;
            }
        }
    }
    
    for (int i = 0; i < roomsSize; i++) {
        if (!visited[i]) {
            free(visited);
            free(keys);
            return false;
        }
    }
    
    free(visited);
    free(keys);
    return true;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we might scan all n rooms up to n times

⚠ Quadratic Growth

Space Complexity

O(n)

Need space to store visited rooms and collected keys

⚡ Linearithmic Space

68.5K Views

Medium Frequency

~15 min Avg. Time

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Naive Exploration) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler