代码随想录算法训练营第51天|99. 岛屿数量、100. 岛屿的最大面积

1. 99. 岛屿数量（深度优先遍历）

题目链接：99. 岛屿数量
文档讲解： 代码随想录

本题思路，是用遇到的一个没有遍历过的节点陆地，计数器加一，然后把该节点陆地所能遍历到的陆地都标记上。在遇到标记过陆地节点和海洋节点都直接跳过，这样计数器就是最终岛屿的数量。

direction = [[0,1],[0,-1],[-1,0],[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_y < 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 
            dfs(grid,visited,next_x,next_y)

n,m = map(int,input().split())
grid = []
for _ in range(n):
    grid.append(list(map(int,input().split())))
count = 0
#访问表
visited = [[False] * m for _ in range(n)]
for i in range(n):
    for j in range(m):
        #判断
        if grid[i][j] == 1 and not visited[i][j]:
            count += 1 
            visited[i][j] = True 
            dfs(grid,visited,i,j)
print(count)

direction = [[0,1],[0,-1],[1,0],[-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)
n,m = map(int,input().split())
grid = []
for _ in range(n):
    grid.append(list(map(int,input().split())))
res = 0
visited = [[False] * m for _ in range(n)]
for i in range(n):
    for j in range(m):
        if not visited[i][j] and grid[i][j] == 1:
            res += 1 
            dfs(grid,visited,i,j)
print(res)

2. 99. 岛屿数量（广度优先遍历）

题目链接：99. 岛屿数量
文档讲解： 代码随想录

只要节点加入队列就代表走过，就需要标记，而不是从队列拿出来的时候再标记走过。

from collections import deque
direction = [[0,1],[0,-1],[1,0],[-1,0]]
def bfs(grid,visited,x,y):
    queue = deque()
    queue.append((x,y))
    #只要入队列就标记访问过
    visited[x][y] = True
    while queue:
        #队列不为空
        cur = queue.popleft()
        cur_x = cur[0]
        cur_y = cur[1]
        for i,j in direction:
            next_x = cur_x + i 
            next_y = cur_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:
                queue.append((next_x,next_y))
                visited[next_x][next_y] = True
n,m = map(int,input().split())
grid = []
for _ in range(n):
    grid.append(list(map(int,input().split())))
res = 0
visited = [[False] * m for _ in range(n)]
for i in range(n):
    for j in range(m):
        if not visited[i][j] and grid[i][j] == 1:
            res += 1 
            bfs(grid,visited,i,j)
print(res)

3. 100. 岛屿的最大面积

题目链接：100. 岛屿的最大面积
文档讲解： 代码随想录

这道题在上一题的基础上需要统计岛屿的面积。

#深度优先遍历
direction = [[0,1],[0,-1],[1,0],[-1,0]]
count = 0
def dfs(grid,visited,x,y,res):
    #定义全局变量
    global count
    
    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
            count += 1 
            dfs(grid,visited,next_x,next_y,res)

n,m = map(int,input().split())
grid = []
for _ in range(n):
    grid.append(list(map(int,input().split())))
visited = [[False] * m for _ in range(n)]
max_res = 0
for i in range(n):
    for j in range(m):
        if not visited[i][j] and grid[i][j] == 1:
            count = 1
            visited[i][j] = True
            dfs(grid,visited,i,j,0)
            max_res = max(max_res,count)
print(max_res)

在 Python 中，global 关键字用于在函数内部声明一个变量是全局变量，而不是函数内部的局部变量。使用 global 可以使得函数内部对变量的修改反映到函数外部的全局范围。

#广度优先遍历
from collections import deque
direction = [[0,1],[0,-1],[1,0],[-1,0]]
count = 0
def bfs(grid,visited,x,y):
    global count 
    que = deque()
    que.append([x,y])
    visited[x][y] = True
    while que:
        cur = que.popleft()
        for i,j in direction:
            next_x = cur[0] + i 
            next_y = cur[1] + 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:
                count += 1 
                que.append([next_x,next_y])
                visited[next_x][next_y] = True 
n,m = map(int,input().split())
grid = []
for _ 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 not visited[i][j] and grid[i][j] == 1:
            count = 1
            bfs(grid,visited,i,j)
            res = max(res,count)
print(res)