代码随想录算法训练营第五十六天| 图论2—卡码网99. 岛屿数量（dfs & bfs）

假期归来继续刷题，图论第二天，主要是进一步熟悉dfs 和 bfs 的运用。

99. 岛屿数量（dfs）

ACM模式还是需要练，不过现在输入输出的感觉已经比较熟悉了。首先是要按照输入搭建一个grid，然后有一个对应的全是False 的 visit。

关于方向就只有上下左右四个，如果可以走斜向，方向就变成八个了。递归的过程其实比较好理解，就是当前x，y逐步相加，如果越界了就continue，然后如果碰到了grid中为1但没有visit的，就变成visit继续向后递归，当四边都没法符合判断条件的话就进行返回，这就是dfs顺着一条路走下去的思想。

然后是主函数中的调用，当碰到第一个符合条件的地块开始，并计数，记得同时将这块变为True，因为dfs函数里直接是从下一个地块开始转换的。然后不停递归，当结束的时候，就继续回到主函数的遍历中，去测下一个符合if grid[i][j] == 1 and not visited[i][j]:条件的地块，当碰到就是第二块岛，记得将数量+1然后继续递归。

简单理解，主函数中，i，j二次遍历，一旦找到一个为1的地块便计数+1，同时dfs开始，当dfs遍历完之后，i，j继续遍历，这时候如果遍历到之前dfs遍历的地块，也会因为visit中为True而不会开始dfs。可以想象成发现一个起点，dfs开始逐步扩散发掘所有连着的地块。

python 复制代码

# dfs方法一
direction = [[0, 1], [1, 0], [0, -1], [-1, 0]] 

def dfs(grid, visited, x, y):
    for i, j in direction:
        next_x = x + i
        next_y = y + j
        if next_x < 0 or next_x >= len(grid) or next_y < 0 or next_y >= len(grid[0]):
            continue
        if not visited[next_x][next_y] and grid[next_x][next_y] == 1:
            visited[next_x][next_y] = True
            dfs(grid, visited, next_x, next_y)


if __name__ == '__main__':  
    n, m = map(int, input().split())
    
    grid = []
    for i in range(n):
        grid.append(list(map(int, input().split())))
    
    visited = [[False] * m for _ in range(n)]
    
    res = 0
    for i in range(n):
        for j in range(m):
            # 判断：如果当前节点是陆地，res+1并标记访问该节点，使用深度搜索标记相邻陆地。
            if grid[i][j] == 1 and not visited[i][j]:
                res += 1
                visited[i][j] = True
                dfs(grid, visited, i, j)
    
    print(res)

dfs的版本二，变化不大，总体方法更符合之前回溯的模板，即参数-终止条件-单层逻辑。

版本一的写法是：下一个节点是否能合法已经判断完了，传进dfs函数的就是合法节点。

版本二的写法是：不管节点是否合法，上来就dfs，然后在终止条件的地方进行判断，不合法再return。

理论上来讲，版本一的效率更高一些，因为避免了没有意义的递归调用，在调用dfs之前，就做合法性判断。但从写法来说，可能版本二更利于理解一些。（不过其实都差不太多）

python 复制代码

direction = [[0, 1], [1, 0], [0, -1], [-1, 0]] 

def dfs(grid, visited, x, y):
    # 与版本一的差别，在调用前增加判断终止条件
    if visited[x][y] or grid[x][y] == 0:
        return
    visited[x][y] = True

    for i, j in direction:
        next_x = x + i
        next_y = y + j
        if next_x < 0 or next_x >= len(grid) or next_y < 0 or next_y >= len(grid[0]):
            continue
        dfs(grid, visited, next_x, next_y)


if __name__ == '__main__':
    # 版本二
    n, m = map(int, input().split())

    grid = []
    for i in range(n):
        grid.append(list(map(int, input().split())))

    visited = [[False] * m for _ in range(n)]

    res = 0
    for i in range(n):
        for j in range(m):
            # 判断：如果当前节点是陆地，res+1并标记访问该节点，使用深度搜索标记相邻陆地。
            if grid[i][j] == 1 and not visited[i][j]:
                res += 1
                dfs(grid, visited, i, j)

    print(res)

99. 岛屿数量（bfs）

深搜是一条路走到头，广搜则是一圈一圈的扩散，可以类比为二叉树的层序遍历，原本是每个节点有左右两个子节点，现在变成每个地块有上下左右四个地块。

在bfs函数里，记住每开始一次bfs，要重置一次que，然后将当前的地块x,y 加入队列，并在visit中变成True。之后便是弹出，符合条件加入，重复直到队列为空。

之后主函数调用则是一样的思路，类似发现一个起点，然后一圈一圈开始扩散，直到无法扩散，便开始遍历寻找下一个岛屿的起点。

python 复制代码

from collections import deque
directions = [[0, 1], [1, 0], [0, -1], [-1, 0]]
def bfs(grid, visited, x, y):
    que = deque([])
    que.append([x,y])
    visited[x][y] = True
    while que:
        cur_x, cur_y = que.popleft()
        for i, j in directions:
            next_x = cur_x + i
            next_y = cur_y + j
            if next_y < 0 or next_x < 0 or next_x >= len(grid) or next_y >= len(grid[0]):
                continue
            if not visited[next_x][next_y] and grid[next_x][next_y] == 1: 
                visited[next_x][next_y] = True
                que.append([next_x, next_y])
 
 
if __name__ == "__main__":
    n, m = map(int, input().split())
    grid = []
    for i in range(n):
        grid.append(list(map(int, input().split())))
    visited = [[False] * m for _ in range(n)]
    res = 0
    for i in range(n):
        for j in range(m):
            if grid[i][j] == 1 and not visited[i][j]:
                res += 1
                bfs(grid, visited, i, j)
    print(res)