LeetCode 841 Keys and Rooms

841 Keys and Rooms

https://leetcode.com/problems/keys-and-rooms/

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.

basic solution

本质是一个有向图的可达问题，从 0 出发是否可以访问到每个点，采用深度优先算法进行遍历。

时间复杂度 O(n^2)，空间复杂度 O(n)

第一次提交出现运行时间超时的问题，dfs 中增加判定条件，只去访问没到达过的房间，防止陷入回路死循环。

class Solution {
public:
    bool canVisitAllRooms(vector<vector<int>>& rooms) {
        int n = rooms.size();
        vector<bool> reach(n, false);
        dfs(rooms, reach, 0);
        for(bool f : reach){
            if(f == false)  return false;
        }
        return true;
    }
private:
    void dfs(vector<vector<int>>& rooms, vector<bool>& reach, int d){
        reach[d] = true;
        for(int i : rooms[d]) {
            if(reach[i] == false) dfs(rooms, reach, i);
        }  
    }
};

Runtime: 4 ms, faster than 99.47% of C++ online submissions for Keys and Rooms.

Memory Usage: 10.5 MB, less than 67.30% of C++ online submissions for Keys and Rooms.