(BFS DFS 图的遍历) leetcode 841. 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.

 

这个题中，就出说的是，开始的地方拿到钥匙，然后用钥匙打开对应的已经锁了的门，并拿到门的钥匙（如果有的话），然后再打开对应的锁住的门，一直到没有钥匙为止。

可以都用BFS和DFS

 

BFS代码：（C++）

这个BFS题中，我们先把开始的地方（即rooms[0]）里面的所有数加到队列中，并把rooms[0]记为已经访问过的门，然后依次遍历，并把遍历到的门记为访问过的。

class Solution {
public:
    bool canVisitAllRooms(vector<vector<int>>& rooms) {
        int m = rooms.size();
        int n = rooms[0].size();
        vector<bool> vis(m,false); 
        queue<int> q;
        for(int i : rooms[0]){
            q.push(i);
        }
        vis[0] = true;
        while(!q.empty()){
            int t = q.front();q.pop();
            if(!vis[t]){
                for(int i : rooms[t]){
                    q.push(i);
                }
                vis[t] = true;
            }
        }
        for(int i = 0; i < m; i++){
            if(vis[i] == false)
                return false;
        }
        return true;
    }
};

 

DFS解法，参考Grandyang的博客：https://www.cnblogs.com/grandyang/p/10415773.html

class Solution {
public:
    bool canVisitAllRooms(vector<vector<int>>& rooms) {
        unordered_set<int> s;
        dfs(rooms,s,0);
        return s.size() == rooms.size();
    }
    void dfs(vector<vector<int> > &rooms,unordered_set<int> &s,int cur){
        s.insert(cur);
        for(int i : rooms[cur]){
            if(!s.count(i))
                dfs(rooms,s,i);
        }
    }
};