【leetcode】695. 岛屿的最大面积（python）+ 本地测试（广度优先搜索 / 深度优先搜索）

思路承接上一篇【733. 图像渲染】，广度优先，只不过这里需要注意：把已经检索过的置为0，这样就不会重复检索了。
（一开始写的时候总是多算一个，结果print看了一下，发现忘记在队列的初始元素置零了。）

import collections
class Solution(object):
    def maxAreaOfIsland(self, grid):
        """
        :type grid: List[List[int]]
        :rtype: int
        """
        m, n = len(grid), len(grid[0])
        max_num = 0
        for i in range(m):
            for j in range(n):
                if grid[i][j] == 1:
                    cur_num = 0
                    que = collections.deque([(i, j)])
                    while que:
                        x, y = que.popleft()
                        grid[x][y] = 0  # 不要忘记置0！
                        cur_num += 1
#                         print((i, j),cur_num)
                        for mx, my in [(x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1)]:
                            if 0 <= mx < m and 0 <= my < n and grid[mx][my] == 1:
                                que.append((mx, my))
#                                 print((mx, my))
                                grid[mx][my] = 0
                    if cur_num > max_num:
                        max_num = cur_num
        return max_num

本地测试

# grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],
#         [0,0,0,0,0,0,0,1,1,1,0,0,0],
#         [0,1,1,0,1,0,0,0,0,0,0,0,0],
#         [0,1,0,0,1,1,0,0,1,0,1,0,0],
#         [0,1,0,0,1,1,0,0,1,1,1,0,0],
#         [0,0,0,0,0,0,0,0,0,0,1,0,0],
#         [0,0,0,0,0,0,0,1,1,1,0,0,0],
#         [0,0,0,0,0,0,0,1,1,0,0,0,0]]

grid = [[0,0,0,0,0,0,0,0],[1,1,1,1,0,1,1,0]]

# grid = [[0,0,0,0,0,0,0,0]]

solution = Solution()
solution.maxAreaOfIsland(grid)

ps：学习一下官方题解中的写法【官方题解】。

方法一：广度优先

class Solution:
    def maxAreaOfIsland(self, grid):
        ans = 0
        for i, l in enumerate(grid):
            for j, n in enumerate(l):
                cur = 0
                stack = [(i, j)]
                while stack:
                    cur_i, cur_j = stack.pop()
                    if cur_i < 0 or cur_j < 0 or cur_i == len(grid) or cur_j == len(grid[0]) or grid[cur_i][cur_j] != 1:
                        continue
                    cur += 1
                    grid[cur_i][cur_j] = 0
                    for di, dj in [[0, 1], [0, -1], [1, 0], [-1, 0]]:
                        next_i, next_j = cur_i + di, cur_j + dj
                        stack.append((next_i, next_j))
                ans = max(ans, cur)
        return ans

方法二：深度优先

class Solution:
    def dfs(self, grid, cur_i, cur_j):
        if cur_i < 0 or cur_j < 0 or cur_i == len(grid) or cur_j == len(grid[0]) or grid[cur_i][cur_j] != 1:
            return 0
        grid[cur_i][cur_j] = 0
        ans = 1
        for di, dj in [[0, 1], [0, -1], [1, 0], [-1, 0]]:
            next_i, next_j = cur_i + di, cur_j + dj
            ans += self.dfs(grid, next_i, next_j)
        return ans

    def maxAreaOfIsland(self, grid):
        ans = 0
        for i, l in enumerate(grid):
            for j, n in enumerate(l):
                ans = max(self.dfs(grid, i, j), ans)
        return ans

方法三：深度优先+栈

class Solution:
    def maxAreaOfIsland(self, grid):
        ans = 0
        for i, l in enumerate(grid):
            for j, n in enumerate(l):
                cur = 0
                stack = [(i, j)]
                while stack:
                    cur_i, cur_j = stack.pop()
                    if cur_i < 0 or cur_j < 0 or cur_i == len(grid) or cur_j == len(grid[0]) or grid[cur_i][cur_j] != 1:
                        continue
                    cur += 1
                    grid[cur_i][cur_j] = 0
                    for di, dj in [[0, 1], [0, -1], [1, 0], [-1, 0]]:
                        next_i, next_j = cur_i + di, cur_j + dj
                        stack.append((next_i, next_j))
                ans = max(ans, cur)
        return ans