leetcode 841. Keys and Rooms（房间和钥匙）

蓝羽飞鸟

已于 2022-12-22 09:47:23 修改

阅读量186

点赞数

分类专栏： leetcode 文章标签： leetcode 算法

于 2020-12-30 23:43:03 首次发布

本文链接：https://blog.csdn.net/level_code/article/details/112000399

版权

leetcode 专栏收录该内容

490 篇文章 4 订阅

订阅专栏

这篇博客讨论了如何解决一个算法问题：从0号房间出发，判断能否到达所有房间。通过深度优先搜索（DFS）和广度优先搜索（BFS）两种方法实现，检查每个房间是否都能从0号房间访问到。如果所有房间都被访问过，则返回true，否则返回false。示例展示了两种方法的代码实现，确保所有房间都能到达。

摘要由CSDN通过智能技术生成

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 <= rooms.length <= 1000
0 <= rooms[i].length <= 1000
The number of keys in all rooms combined is at most 3000.

每个房间有进入其他房间的钥匙，最开始只能进入0号房间，问从0号房间出发是否能到达所有房间

思路：

1.DFS
从0出发DFS，用visited数组记录下被访问过的房间，最后只要visited数组中存在false就说明有房间不能到达

    public boolean canVisitAllRooms(List<List<Integer>> rooms) {
        int n = rooms.size();
        boolean[] visited = new boolean[n];
        
        dfs(rooms, visited, 0);
        
        for(int i = 0; i < n; i++) {
            if(!visited[i]) return false;
        }
        return true;
    }
    
    void dfs(List<List<Integer>> rooms, boolean[] visited, int room) {
        if(visited[room]) return;
        
        visited[room] = true;
        for(Integer nextRoom : rooms.get(room)) {
            dfs(rooms, visited, nextRoom);
        }
    }

2.BFS

    public boolean canVisitAllRooms(List<List<Integer>> rooms) {
        int n = rooms.size();
        Queue<Integer> queue = new LinkedList<>();
        boolean[] visited = new boolean[n];

        queue.offer(0);
        visited[0] = true;

        while(!queue.isEmpty()) {
            int size = queue.size();
            for(int i = 0; i < size; i++) {    
                int curRoom = queue.poll();           
                for(int nextRoom : rooms.get(curRoom)) {
                    if(visited[nextRoom]) continue;                   
                    queue.offer(nextRoom);
                    visited[nextRoom] = true;
                }
            }
        }
        for(int i = 0; i < n; i++) {
            if(!visited[i]) return false;
        }
        return true;
    }