广度和深度

广度优先给人的感觉是一层层遍历邻居的，深度优先是先往一条路走到头。

class Solution:
    def dfs_recursive(self, graph, u, visited):
        print(u)  # 访问节点
        visited.add(u)  # 节点 u 标记其已访问

        for v in graph[u]:
            if v not in visited:  # 节点 v 未访问过
                # 深度优先搜索遍历节点
                self.dfs_recursive(graph, v, visited)
class Solution:
    def bfs(self, graph, u):
        visited = set()                     # 使用 visited 标记访问过的节点
        queue = collections.deque([])       # 使用 queue 存放临时节点
        
        visited.add(u)                      # 将起始节点 u 标记为已访问
        queue.append(u)                     # 将起始节点 u 加入队列中
        
        while queue:                        # 队列不为空
            u = queue.popleft()             # 取出队头节点 u
            print(u)                        # 访问节点 u
            for v in graph[u]:              # 遍历节点 u 的所有未访问邻接节点 v
                if v not in visited:        # 节点 v 未被访问
                    visited.add(v)          # 将节点 v 标记为已访问
                    queue.append(v)         # 将节点 v 加入队列中

 以上是遍历一个图的结果，当然是相同的。在给定的图中，无论是DFS还是BFS，我们都会遍历每个节点，并且节点之间没有环路，因此它们的结果是一样的，即从节点0开始，按顺序遍历所有节点直到结束。

deque是collection函数,创建一个队列。

重点在于广度优先多了一个"queue"，来储存节点v，而深度优先并没有，只能用递归。

        directs = [(0, 1), (0, -1), (1, 0), (-1, 0)]#广度优先
        rows, cols = len(grid), len(grid[0])
        ans = 0
        for i in range(rows):
            for j in range(cols):
                if grid[i][j] == 1:
                    grid[i][j] = 0
                    temp_ans = 1
                    queue = collections.deque([(i, j)])
                    while queue:
                        i, j = queue.popleft()
                        for direct in directs:
                            new_i = i + direct[0]
                            new_j = j + direct[1]
                            if new_i < 0 or new_i >= rows or new_j < 0 or new_j >= cols or grid[new_i][new_j] == 0:
                                continue
                            grid[new_i][new_j] = 0
                            queue.append((new_i, new_j))
                            temp_ans += 1
    def dfs(self, grid, i, j):#深度优先
        n = len(grid)
        m = len(grid[0])
        if i < 0 or i >= n or j < 0 or j >= m or grid[i][j] == '0':
            return 0
        grid[i][j] = '0'
        self.dfs(grid, i + 1, j)
        self.dfs(grid, i, j + 1)
        self.dfs(grid, i - 1, j)
        self.dfs(grid, i, j - 1)

    def numIslands(self, grid: List[List[str]]) -> int:
        count = 0
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                if grid[i][j] == '1':
                    self.dfs(grid, i, j)
                    count += 1
        return count

就是用深度优先来求岛屿数量和用广度优先求最大的岛屿面积，前者类似从上下左右同时进行到底，而后者从一点开始，不行再从另一点。

同样地对于克隆图，广度优先多了一个"queue"，来储存节点v，而深度优先并没有，只能用递归。

class Solution:
    def cloneGraph(self, node: 'Node') -> 'Node':
        if not node:
            return node
        visitedDict = dict()

        def dfs(node: 'Node') -> 'Node':
            if node in visitedDict:
                return visitedDict[node]

            clone_node = Node(node.val, [])
            visitedDict[node] = clone_node
            for neighbor in node.neighbors:
                clone_node.neighbors.append(dfs(neighbor))
            return clone_node

        return dfs(node)

这里return的node是clone_node,即第一个node