0841钥匙与房间 Marathon

有 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] 的值 互不相同

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/keys-and-rooms

参考：

• https://leetcode-cn.com/problems/keys-and-rooms/solution/841-yao-chi-he-fang-jian-ben-zhi-shi-gu-dao-wen-ti/

python

# 0841.钥匙和房间

class Solution:
    def canVisitAllRooms(self, rooms: [[int]]) -> bool:
        """
        有向图，广度优先-BFS
        :param rooms:
        :return:
        """
        def bfs(rooms):
            visited = [0 for _ in range(len(rooms))] # 标记房间是否访问过
            visited[0] = 1 # 0号房间
            queue = []
            queue.append(0) # 0号房间开始

            # BFS
            while queue:
                key = queue.pop() # 下标
                keys = rooms[key] # 获取对应下标的钥匙
                for key_ in keys: # 遍历钥匙
                    if not visited[key_]: # 钥匙没有遇到过的
                        queue.append(key_) # 加入队列
                        visited[key_] = 1 # 标记已经访问过
            # 检查房间是不是都遍历了
            for val in visited:
                if val == 0: # 房间没有遍历过
                    return False
            return True

        return bfs(rooms)

    def canVisitAllRooms_(self, rooms: [[int]]) -> bool:
        """
        有向图，深度优先-DFS
        :param rooms:
        :return:
        """
        def dfs(key, rooms, visited):
            if visited[key]:
                return
            visited[key] = 1
            keys = rooms[key]
            for key_ in keys:
                dfs(key_, rooms, visited)

        visited = [0 for _ in range(len(rooms))]
        dfs(0, rooms, visited)
        # 检查是否都遍历了
        for val in visited:
            if val == 0:
                return False
        return True

golang

package MAP

// 有向图-BFS, LC未过！
func canVistiedAllROoms(rooms [][]int) bool {
	var bfs func(rooms [][]int) bool
	bfs = func(rooms [][]int) bool {
		visited := make([]int, len(rooms))
		for i := range visited {
			visited[i] = 0
		}
		visited[0] = 1
		queue := make([]int, 1)
		queue[0] = 0
		// bfs
		for len(queue) > 0 {
			key := queue[len(queue)-1]
			queue = queue[:len(queue)-1]
			keys := rooms[key]
			for i:=0;i<len(keys);i++ {
				if visited[keys[i]] != 0 {
					queue = append(queue, keys[i])
					visited[keys[i]] = 1
				}
			}
		}
		// 检查是否都访问过
		for _, val := range visited {
			if val == 0 {
				return false
			}
		}
		return true
	}
	return bfs(rooms)
}

// 有向图-dfs
func canVisitedAllRooms_(rooms [][]int) bool {
	var dfs func(key int, rooms [][]int, visited []int)
	dfs = func(key int, rooms [][]int, visited []int) {
		if visited[key] == 1 {
			return
		}
		visited[key] = 1
		keys := rooms[key]
		for _, key_ := range keys {
			dfs(key_, rooms, visited)
		}
	}
	visited := make([]int, len(rooms))
	for i := range visited {
		visited[i] = 0
	}
	dfs(0, rooms, visited)
	for _, val := range visited {
		if val == 0 {
			return false
		}
	}
	return true
}