leetcode 841. 钥匙和房间(深度优先递归版)

有 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 号房间。
由于我们能够进入每个房间，我们返回 true。

示例 2：

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

提示：

1 <= rooms.length <= 1000
0 <= rooms[i].length <= 1000
所有房间中的钥匙数量总计不超过 3000。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/keys-and-rooms
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

算法思想：深度优先遍历
深度优先递归模板：

深度优先搜索的基本模型
void dfs(int start)
{
  判断边界
  尝试每一种可能  
  for(i=1;i<=n;++i)
  {
      继续下一步 dfs(start+1); 
  } 
  返回  return ;
} 

python代码如下：

class Solution(object):
    def canVisitAllRooms(self, rooms):
        """
        :type rooms: List[List[int]]
        :rtype: bool
        """
        """
        可采用深度优先遍历房间，如果从当前房间找到一个钥匙，
        并且该钥匙对应的下一个没有去过就进入，用mem记录，
        进去为True,否则为false. rooms[i]第i个房间里放的钥匙。
        可将rooms看作邻接表结构,故可进行图的深度优先遍历。
        """
        self.mem = {}
        self.mem[0] = True
        for i in range(1, len(rooms)):
            #初始化时除了房间0，其它都没有进去过，故设为false
            self.mem[i] = False
        self.dfs(rooms, 0)
        for i in range(1, len(rooms)):
            if self.mem[i] == False:
                return False
        return True

    def dfs(self, rooms, start):
        if start < 0 or start > len(rooms):
            return
        self.mem[start] = True
        for key in rooms[start]:
            if self.mem[key] == False:
                self.dfs(rooms, key)

x = Solution()
rooms = [[1],[2],[3],[]]
print(x.canVisitAllRooms(rooms))

go代码：

package main

import "fmt"

func canVisitAllRooms(rooms [][]int) bool {
	var mem map[int]bool
	mem = make(map[int]bool)
	mem[0] = false
	for i := 1; i < len(rooms); i ++ {
		mem[i] = false
	}
	dfs(rooms, 0, mem)
	fmt.Println(mem)
	for i := 1; i < len(rooms); i ++ {
		if mem[i] == false {
			return false
		}
	}
	return true
}

func dfs(rooms [][]int, start int, mem map[int]bool) {
	if mem[start] == false {
		mem[start] = true
	}
	for _, key := range rooms[start] {
		if mem[key] == false {
			dfs(rooms, key, mem)
		}
	}
}

func main() {
	rooms := [][]int{{1}, {2}, {3}, {}}
	fmt.Println(canVisitAllRooms(rooms))
}