LeetCode：841 钥匙与房间（Keys and Rooms）--（java、python）_有n个房间，开始时你位于-优快云博客

本文链接：https://blog.youkuaiyun.com/liuhong3707/article/details/80822593

多益网络2018.06.26笔试编程题：

题目描述：

有 N 个房间，开始时你位于 0 号房间。每个房间有不同的号码：0，1，2，...，N-1，并且房间里可能有一些钥匙能使你进入下一个房间。

在形式上，对于每个房间 i 都有一个钥匙列表 rooms[i]，每个钥匙 rooms[i][j] 由 [0,1，...，N-1] 中的一个整数表示，其中 N = rooms.length。钥匙 rooms[i][j] = v 可以打开编号为 v 的房间。

最初，除 0 号房间外的其余所有房间都被锁住。

你可以自由地在房间之间来回走动。

如果能进入每个房间返回 true，否则返回 false。

要求先写出解题思路，再编写代码。

实例1：

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

实例2：

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

解题思路：有两种方式，第一通过深度优先搜索（DFS）的方式，到了每一个房间就判断钥匙是否存在于已经拥有的序列中，如果不在就把他设置为可以访问。第二通过广度优先搜索（BFS）的方式进行探索。将可访问的0房间加入队列之中，访问队列中的一个元素，遍历他可以到达的房间，如果该房间还不能被访问，那么设置为访问，否则跳过。

下面是利用BFS方式的代码：

java：

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Stack;

public class Main {
	public static boolean canVisitRooms(List<List<Integer>> rooms) {
		//用栈来存储下一步将要参观的房间
		Stack<Integer> todo  = new Stack<>();
		todo.add(0);
		//用hashset放置已经参观过的房间
		HashSet<Integer> done = new HashSet<>();
		done.add(0);
		
		while(!todo.isEmpty()) {
			
			int i = todo.pop();
			//如果当前所在的房间里的钥匙，对应的那个房间不在已经参观的房间里边，
			//那么就将钥匙对应的房间，加入将要参观的房间里，同时也加入已经参观的房间里
			for(Integer j : rooms.get(i)) {
				if(!done.contains(j)) {
					todo.add(j);
					done.add(j);
					//若所有房间都已在已经参观的房间队列，可提前结束
					if(rooms.size() == done.size())
						return true;
				}
			}
		}
		return rooms.size() == done.size();
	}

	public static void main(String[] args) {
		//[[1],[2],[3],[]]
		List<List<Integer>> rooms0 = new ArrayList<>();
		List<Integer> room00 = new ArrayList<>();
		room00.add(1);
		List<Integer> room01 = new ArrayList<>();
		room01.add(2);
		List<Integer> room02 = new ArrayList<>();
		room02.add(3);
		List<Integer> room03 = new ArrayList<>();
		
		rooms0.add(room00);
		rooms0.add(room01);
		rooms0.add(room02);
		rooms0.add(room03);
		System.out.println(canVisitRooms(rooms0)); //true
		
		// [[1,3],[3,0,1],[2],[0]]
		List<List<Integer>> rooms1 = new ArrayList<>();
		List<Integer> room10 = new ArrayList<>();
		room10.add(1);
		room10.add(3);
		List<Integer> room11 = new ArrayList<>();
		room11.add(3);
		room11.add(0);
		room11.add(1);
		List<Integer> room12 = new ArrayList<>();
		room12.add(2);
		List<Integer> room13 = new ArrayList<>();
		room13.add(0);
		rooms1.add(room10);
		rooms1.add(room11);
		rooms1.add(room12);
		rooms1.add(room13);
		System.out.println(canVisitRooms(rooms1)); //false
	}
}

python：

# -*- coding: utf-8 -*-
"""
Created on Tue Jun 26 22:46:25 2018
@author: Hong
钥匙与房间
"""

def canVisitAllRooms(rooms):
    todo = [0] #现在所在的房间，初始化为0号房间
    done = set(todo) # 已经进入过的房间，刚开始时也是0号
    while todo:
        i = todo.pop()
        for j in rooms[i]:
            #如果当前房间里的钥匙对应的房间不在已经参观过的
            #房间集合中，下一步便去参观那个房间
            if j not in done:
                todo.append(j)
                done.add(j)
                #若所有房间都在已参观的房间之列，可提前结束
                if len(rooms) == len(done):return True
    return len(rooms) == len(done)

if __name__ == '__main__':
    rooms1 = [[1], [2], [3], []]
    print(canVisitAllRooms(rooms1)) #True
    
    rooms2 = [[1,3], [3,0,1], [2], [0]]
    print(canVisitAllRooms(rooms2)) #False

参考：

LeetCode代码链接：https://leetcode.com/problems/keys-and-rooms/discuss/133855/Straight-Forward

Youtube英文视频讲解链接（能访问YouTube的同学才能打开哟）

https://www.youtube.com/watch?v=AWLims83GcU&feature=youtu.be