0841. Keys and Rooms (M)

Keys and Rooms (M)

题目

There are N rooms and you start in room 0. Each room has a distinct number in 0, 1, 2, ..., N-1, and each room may have some keys to access the next room.

Formally, each room i has a list of keys rooms[i], and each key rooms[i][j] is an integer in [0, 1, ..., N-1] where N = rooms.length. A key rooms[i][j] = v opens the room with number v.

Initially, all the rooms start locked (except for room 0).

You can walk back and forth between rooms freely.

Return true if and only if you can enter every room.

Example 1:

Input: [[1],[2],[3],[]]
Output: true
Explanation:  
We start in room 0, and pick up key 1.
We then go to room 1, and pick up key 2.
We then go to room 2, and pick up key 3.
We then go to room 3.  Since we were able to go to every room, we return true.

Example 2:

Input: [[1,3],[3,0,1],[2],[0]]
Output: false
Explanation: We can't enter the room with number 2.

Note:

1. 1 <= rooms.length <= 1000
2. 0 <= rooms[i].length <= 1000
3. The number of keys in all rooms combined is at most 3000.

---

题意

给定一个数组，其中每一个元素代表一个房间，每个房间中有若干把钥匙，每把钥匙能打开一个房间。问从房间0出发，能否打开所有房间。

思路

直接当作图DFS遍历即可。

---

代码实现

Java

class Solution {
    public boolean canVisitAllRooms(List<List<Integer>> rooms) {
        boolean[] visited = new boolean[rooms.size()];
        dfs(rooms, 0, visited);

        for (boolean flag : visited) {
            if (!flag) return false;
        }
        return true;
    }

    private void dfs(List<List<Integer>> rooms, int index, boolean[] visited) {
        visited[index] = true;
        
        for (int next : rooms.get(index)) {
            if (!visited[next]) {
                visited[next] = true;
                dfs(rooms, next, visited);
            }
        }
    }
}