695. 岛屿的最大面积（中等）- LeetCode

题目描述

自己解法

广度优先搜索（BFS），遍历过的点都置0，时间复杂度$O(m\ast n)$，空间复杂度$O(min[m,n])$

class Solution:
    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
        maxArea = 0
        H,W = len(grid),len(grid[0])
        queue = collections.deque()
        for i in range(H):
            for j in range(W):
                chooseArea = 0
                if grid[i][j] == 0:
                    continue
                else:
                    chooseArea += 1
                    queue += [(i,j)]
                    grid[i][j] = 0  
                    while queue:
                        x,y = queue.popleft()                      
                        for k,m in [(x-1,y),(x+1,y),(x,y+1),(x,y-1)]:
                            if 0 <= k < H and 0 <= m < W and grid[k][m] == 1:
                                chooseArea += 1
                                queue += [(k,m)]
                                grid[k][m] = 0
                    maxArea = max(maxArea,chooseArea)
        return maxArea

这题可以用深度优先搜索（DFS），时间复杂度$O(m\ast n)$，空间复杂度$O(m\ast n)$自己实现的代码如下，

class Solution:
    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
        maxArea = 0
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                maxArea = max(maxArea,self.dfs(i,j,grid))
        return maxArea
    
    def dfs(self,x,y,grid):
        ans = 0
        if grid[x][y] == 1:
            grid[x][y] = 0
            ans += 1
            for k,m in [(x-1,y),(x+1,y),(x,y+1),(x,y-1)]:
                if 0 <= k < len(grid) and 0 <= m < len(grid[0]):
                    ans += self.dfs(k,m,grid)
        return ans

可以看出DFS栈消耗的空间明显多于BFS队列消耗的空间，符合空间复杂度的分析。

官方解答

参考链接

官方解法中也是采取了深度优先搜索和广度优先搜索两种方法，深度优先搜索（DFS）的代码是：

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: List[List[int]]) -> int:
        ans = 0
        for i, l in enumerate(grid):
            for j, n in enumerate(l):
                ans = max(self.dfs(grid, i, j), ans)
        return ans

广度优先搜索（BFS）的代码是：

class Solution:
    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
        ans = 0
        for i, l in enumerate(grid):
            for j, n in enumerate(l):
                cur = 0
                q = collections.deque([(i, j)])
                while q:
                    cur_i, cur_j = q.popleft()
                    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
                        q.append((next_i, next_j))
                ans = max(ans, cur)
        return ans