**Physical Address**

304 North Cardinal St.

Dorchester Center, MA 02124

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`

**Example 1:**

```
Input: rooms = [[1],[2],[3],[]]
Output: true
Explanation:
We visit room 0 and pick up key 1.
We then visit room 1 and pick up key 2.
We then visit room 2 and pick up key 3.
We then visit room 3.
Since we were able to visit every room, we return true.
```

**Example 2:**

```
Input: rooms = [[1,3],[3,0,1],[2],[0]]
Output: false
Explanation: We can not enter room number 2 since the only key that unlocks it is in that room.
```

**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**.

```
bool canVisitAllRooms(vector<vector<int>>& rooms) {
stack<int> dfs; dfs.push(0);
unordered_set<int> seen = {0};
while (!dfs.empty()) {
int i = dfs.top(); dfs.pop();
for (int j : rooms[i])
if (seen.count(j) == 0) {
dfs.push(j);
seen.insert(j);
if (rooms.size() == seen.size()) return true;
}
}
return rooms.size() == seen.size();
}
```

```
public boolean canVisitAllRooms(List<List<Integer>> rooms) {
Stack<Integer> dfs = new Stack<>(); dfs.add(0);
HashSet<Integer> seen = new HashSet<Integer>(); seen.add(0);
while (!dfs.isEmpty()) {
int i = dfs.pop();
for (int j : rooms.get(i))
if (!seen.contains(j)) {
dfs.add(j);
seen.add(j);
if (rooms.size() == seen.size()) return true;
}
}
return rooms.size() == seen.size();
}
```

```
def canVisitAllRooms(self, rooms):
dfs = [0]
seen = set(dfs)
while dfs:
i = dfs.pop()
for j in rooms[i]:
if j not in seen:
dfs.append(j)
seen.add(j)
if len(seen) == len(rooms): return True
return len(seen) == len(rooms)
```

In our experience, we suggest you solve this Keys and Rooms LeetCode Solution and gain some new skills from Professionals completely free and we assure you will be worth it.

If you are stuck anywhere between any coding problem, just visit Queslers to get the Keys and Rooms LeetCode Solution

I hope this Keys and Rooms LeetCode Solution would be useful for you to learn something new from this problem. If it helped you then don’t forget to bookmark our site for more Coding Solutions.

This Problem is intended for audiences of all experiences who are interested in learning about Data Science in a business context; there are no prerequisites.

Keep Learning!

**More Coding Solutions >>**