网格图学习（附题单与做题思路）

一、DFS 经典题型

1. 岛屿的最大面积
   • LeetCode 695
   • 描述：求网格中最大的陆地连通区域面积
   • 解题：DFS 遍历所有相邻陆地，标记已访问
   • 关键点：递归遍历，适合连通性问题

695. 岛屿的最大面积

题目链接
给你一个大小为 m x n 的二进制矩阵 grid 。

岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在 水平或者竖直的四个方向上 相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。

岛屿的面积是岛上值为 1 的单元格的数目。

计算并返回 grid 中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。

示例 1：
输入：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]]
输出：6
解释：答案不应该是 11 ，因为岛屿只能包含水平或垂直这四个方向上的 1 。

示例 2：
输入：grid = [[0,0,0,0,0,0,0,0]]
输出：0

提示：

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 50
• grid[i][j] 为 0 或 1

class Solution:
    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
        
        """
        时间复杂度：O(m×n)。其中 m 是给定网格中的行数，n 是列数。
        空间复杂度：O(mxn).
        """
        m, n = len(grid), len(grid[0])
        def dfs(x: int, y: int) -> int:
            if x < 0 or y < 0 or x == m or y == n or grid[x][y] != 1:
                return 0
            grid[x][y] = 0
            ans = 1
            for dx, dy in [[0,1],[0,-1],[1,0],[-1,0]]:
                n_x, n_y = x + dx, y + dy
                ans += dfs(n_x, n_y)
            return ans
        
        ans = 0 
        for i, row in enumerate(grid):
            for j, x in enumerate(row):
                ans = max(ans, dfs(i,j))
        return ans
        

二、BFS 经典题型

1. 腐烂的橘子
   • LeetCode 994
   • 描述：多源 BFS 计算所有橘子腐烂的最短时间
   • 解题：队列存储腐烂橘子坐标，逐层扩散
   • 关键点：多源起点，按层处理

994. 腐烂的橘子

题目链接
在给定的 m x n 网格 grid 中，每个单元格可以有以下三个值之一：
值 0 代表空单元格；
值 1 代表新鲜橘子；
值 2 代表腐烂的橘子。
每分钟，腐烂的橘子 周围 4 个方向上相邻 的新鲜橘子都会腐烂。

返回 直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1 。

示例 1：

输入：grid = [[2,1,1],[1,1,0],[0,1,1]]
输出：4

示例 2：
输入：grid = [[2,1,1],[0,1,1],[1,0,1]]
输出：-1
解释：左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个方向上。

示例 3：
输入：grid = [[0,2]]
输出：0
解释：因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0 。

提示：

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 10
• grid[i][j] 仅为 0、1 或 2

class Solution:
    def orangesRotting(self, grid: List[List[int]]) -> int:
        """
        时间复杂度：O(mn)，其中 m 和 n 分别为 grid 的行数和列数。
        空间复杂度：O(mn)。
        """

        m, n = len(grid), len(grid[0])
        fresh = 0 
        q = []
        for i, row in enumerate(grid):
            for j, x in enumerate(row):
                if x == 1:
                    fresh += 1
                elif x == 2:
                    q.append((i, j))
        
        ans = 0
        while q and fresh:
            ans += 1
            tmp = q
            q = []
            for x, y in tmp:
                for i, j in  (x - 1, y), (x + 1, y),(x, y - 1),(x, y + 1):
                    if 0 <= i < m and 0 <= j < n and grid[i][j] == 1:
                        fresh -= 1
                        grid[i][j] = 2
                        q.append((i, j))
        return -1 if fresh else ans

算法选择对照表

问题类型	适用算法	典型题目
连通性 / 面积	DFS	岛屿的最大面积
最短路径 / 时间	BFS	腐烂的橘子

1. 先 DFS 后 BFS：

   • DFS 适合处理连通性问题（如岛屿），BFS 适合最短路径问题（如腐烂橘子）。

2. 掌握多源 BFS：

   • 从多个起点同时扩散（如地图分析），是解决 “最远最短距离” 的高效方法。