(图论) 841. 钥匙和房间 ——【Leetcode每日一题】

❓ 841. 钥匙和房间

难度：中等

有 n 个房间，房间按从 0 到 n - 1 编号。最初，除 0 号房间外的其余所有房间都被锁住。你的目标是进入所有的房间。然而，你不能在没有获得钥匙的时候进入锁住的房间。

当你进入一个房间，你可能会在里面找到一套不同的钥匙，每把钥匙上都有对应的房间号，即表示钥匙可以打开的房间。你可以拿上所有钥匙去解锁其他房间。

给你一个数组 rooms 其中 rooms[i] 是你进入 i 号房间可以获得的钥匙集合。如果能进入 所有 房间返回 true，否则返回 false。

示例 1：

输入：rooms = [[1],[2],[3],[]]
输出：true
解释：
我们从 0 号房间开始，拿到钥匙 1。
之后我们去 1 号房间，拿到钥匙 2。
然后我们去 2 号房间，拿到钥匙 3。
最后我们去了 3 号房间。
由于我们能够进入每个房间，我们返回 true。

示例 2：

输入：rooms = [[1,3],[3,0,1],[2],[0]]
输出：false
解释：我们不能进入 2 号房间。

提示：

• $n==rooms.length$
• $2<=n<=1000$
• $0<=rooms[i].length<=1000$
• $1<=sum(rooms[i].length)<=3000$
• $0<=rooms[i][j]<n$
  所有 $rooms[i]$ 的值 互不相同

💡思路：

可以将每个房间当作图中的结点，钥匙当作图中的边，只要所有结点能够连通，则返回true;

法一：BFS

数组 rooms 的长度即为 房间的总个数：(bfs)

• 可以设置一个数组 open，记录是否找到钥匙；
• 以及一个队列 keys，存储在每个房间取得的钥匙;
• 再另设一个变量 count 记录已打开房间的个数，最后只需比较 count 是否等于房间的总个数。

法二：DFS

我们可以使用深度优先搜索的方式遍历整张图，

统计可以到达的节点个数，并利用数组 open 标记当前节点是否访问过，以防止重复访问。

🍁代码：(C++、Java)

法一：BFS
C++

class Solution {
public:
    bool canVisitAllRooms(vector<vector<int>>& rooms) {
        queue<int> keys;
        vector<int> open(rooms.size());
        open[0] = 1;
        int count = 1;
        for(int k : rooms[0]){
            keys.push(k);
        }
        while(!keys.empty()){
            int key = keys.front();
            keys.pop();
            if(open[key] == 0){
                for(int k : rooms[key]){
                    keys.push(k);
                }
                open[key] = 1;
                count++;
            }
        }
        return count == rooms.size();
    }
};

Java

class Solution {
    public boolean canVisitAllRooms(List<List<Integer>> rooms) {
        Queue<Integer> keys = new LinkedList();
        int[] open = new int[rooms.size()];
        open[0] = 1;
        int count = 1;
        for(int k : rooms.get(0)){
            keys.offer(k);
        }
        while(!keys.isEmpty()){
            int key = keys.poll();
            if(open[key] == 0){
                for(int k : rooms.get(key)){
                    keys.offer(k);
                }
                open[key] = 1;
                count++;
            }
        }
        return count == rooms.size();
    }
}

法二：DFS
C++

class Solution {
private:
    void dfs(const vector<vector<int>>& rooms, int key, vector<int>& open){
        if(open[key] == 1) return;
        open[key] = 1;
        for(int k : rooms[key]){
            dfs(rooms, k, open);
        }
    }
public:
    bool canVisitAllRooms(vector<vector<int>>& rooms) {
        vector<int> open(rooms.size());
        dfs(rooms, 0, open);
        for(int p : open){
            if(p == 0) return false;
        }
        return true;
    }
};

Java

class Solution {
    private void dfs(List<List<Integer>> rooms, int key, int[] open){
        if(open[key] == 1) return;
        open[key] = 1;
        for(int k : rooms.get(key)){
            dfs(rooms, k, open);
        }
    }
    public boolean canVisitAllRooms(List<List<Integer>> rooms) {
        int[] open = new int[rooms.size()];
        dfs(rooms, 0, open);
        for(int p : open){
            if(p == 0) return false;
        }
        return true;
    }
}

🚀 运行结果：

🕔 复杂度分析：

• 时间复杂度：$O(n+m)$，其中 n 为房间的数量，m 是所有房间中的钥匙数量的总数。
• 空间复杂度：$O(n)$，主要为队列（bfs）或栈空间（dfs）的开销。

题目来源：力扣。

放弃一件事很容易，每天能坚持一件事一定很酷，一起每日一题吧！
关注我LeetCode主页 / CSDN—力扣专栏，每日更新！

注： 如有不足，欢迎指正！