LeetCode 130题：被围绕区域的BFS与DFS解法详解-代码聚汇网

LeetCode 130题：被围绕区域的BFS与DFS解法详解

葱切成葱花

1. 问题背景与核心挑战

LeetCode 130题"被围绕的区域"是一个经典的图遍历问题，通常出现在技术面试的中高难度环节。题目要求我们将二维矩阵中所有被'X'完全包围的'O'区域替换为'X'，而保留那些与边界相连的'O'区域。这个看似简单的问题实际上考察了开发者对图遍历算法的深入理解和灵活应用能力。

我第一次遇到这个问题时，直觉反应是应该从矩阵内部的'O'出发，检查它们是否被'X'包围。但实际操作中发现这种思路存在明显缺陷——判断一个区域是否被完全包围的计算成本极高。后来通过反复尝试，才意识到应该采用逆向思维：从边界上的'O'出发，标记所有与之相连的区域，这些就是需要保留的部分，其余内部的'O'则可以安全地替换为'X'。

2. 解法一：广度优先搜索(BFS)实现详解

2.1 BFS算法原理与适用性分析

广度优先搜索采用队列数据结构，按照"近水楼台先得月"的原则层层扩展。对于矩阵问题，BFS特别适合寻找最短路径或连通区域，因为它能保证在发现目标时已经遍历了最小范围的节点。在本问题中，我们需要快速找到所有与边界相连的'O'区域，这正是BFS的拿手好戏。

提示：BFS的空间复杂度通常高于DFS，因为需要维护队列。但在最坏情况下（如整个矩阵都是'O'），两者的空间复杂度都是O(M×N)。

2.2 完整BFS实现代码与逐行解析

python复制from collections import deque

def solve(board):
    if not board:
        return
    
    rows, cols = len(board), len(board[0])
    queue = deque()
    
    # 步骤1：将边界上的'O'加入队列
    for r in range(rows):
        for c in [0, cols-1]:
            if board[r][c] == 'O':
                queue.append((r, c))
                board[r][c] = 'B'  # 标记为待保留
    
    for c in range(cols):
        for r in [0, rows-1]:
            if board[r][c] == 'O':
                queue.append((r, c))
                board[r][c] = 'B'
    
    # 步骤2：BFS扩展标记所有连通区域
    directions = [(-1,0),(1,0),(0,-1),(0,1)]
    while queue:
        r, c = queue.popleft()
        for dr, dc in directions:
            nr, nc = r + dr, c + dc
            if 0 <= nr < rows and 0 <= nc < cols and board[nr][nc] == 'O':
                board[nr][nc] = 'B'
                queue.append((nr, nc))
    
    # 步骤3：最终替换
    for r in range(rows):
        for c in range(cols):
            if board[r][c] == 'B':
                board[r][c] = 'O'
            else:
                board[r][c] = 'X'

关键点解析：

边界预处理：我们首先扫描矩阵的四条边，将边界上的所有'O'入队并标记为'B'（Boundary的缩写）。这一步确保了我们从所有可能的入口点开始搜索。
BFS扩展：使用标准的BFS模板，从队列中取出节点并检查其四个方向（上下左右）的邻居。这里使用directions数组定义四个移动方向，比写四个if语句更简洁。
最终替换：遍历整个矩阵，将标记为'B'的恢复为'O'，其余'O'替换为'X'。这个两阶段的处理方式避免了在搜索过程中直接修改字符导致的逻辑混乱。

2.3 BFS实现中的性能优化技巧

双端队列选择：使用collections.deque而非list作为队列，因为它的popleft()操作是O(1)时间复杂度，而list的pop(0)是O(n)。
原地标记：直接在原矩阵上标记'B'，避免了创建额外的visited矩阵，节省了O(M×N)的空间。
方向数组：将四个移动方向定义为数组，比写四个if语句更简洁且易于维护。如果需要扩展到八方向（如某些变种问题），只需修改这个数组即可。

3. 解法二：深度优先搜索(DFS)实现详解

3.1 DFS算法特点与问题适配性

深度优先搜索采用递归或显式栈的方式，沿着一条路径尽可能深入，直到无法继续才回溯。对于矩阵中的连通区域问题，DFS通常代码更简洁，但需要注意递归深度可能带来的栈溢出风险。在实际面试中，面试官可能会要求解释两种方法的优劣并比较它们的适用场景。

3.2 递归版DFS实现与关键点

python复制def solve(board):
    if not board:
        return
    
    rows, cols = len(board), len(board[0])
    
    def dfs(r, c):
        if not (0 <= r < rows and 0 <= c < cols) or board[r][c] != 'O':
            return
        board[r][c] = 'B'
        dfs(r+1, c)
        dfs(r-1, c)
        dfs(r, c+1)
        dfs(r, c-1)
    
    # 边界处理
    for r in range(rows):
        for c in [0, cols-1]:
            dfs(r, c)
    for c in range(cols):
        for r in [0, rows-1]:
            dfs(r, c)
    
    # 最终替换
    for r in range(rows):
        for c in range(cols):
            board[r][c] = 'O' if board[r][c] == 'B' else 'X'

DFS实现的关键特点：

递归的简洁性：DFS的递归实现通常比BFS更简洁，只需定义好base case和递归关系即可。
隐式栈：递归调用利用函数调用栈自动处理回溯，不需要显式维护数据结构。
方向处理：这里采用了四个独立的递归调用而非循环，虽然代码稍长但执行效率相当。

3.3 迭代版DFS实现与栈的应用

对于大规模矩阵，递归可能导致栈溢出。这时可以使用显式栈实现迭代版DFS：

python复制def solve(board):
    if not board:
        return
    
    rows, cols = len(board), len(board[0])
    stack = []
    
    # 边界初始化
    for r in range(rows):
        for c in [0, cols-1]:
            if board[r][c] == 'O':
                stack.append((r, c))
                board[r][c] = 'B'
    for c in range(cols):
        for r in [0, rows-1]:
            if board[r][c] == 'O':
                stack.append((r, c))
                board[r][c] = 'B'
    
    # 迭代DFS
    directions = [(-1,0),(1,0),(0,-1),(0,1)]
    while stack:
        r, c = stack.pop()
        for dr, dc in directions:
            nr, nc = r + dr, c + dc
            if 0 <= nr < rows and 0 <= nc < cols and board[nr][nc] == 'O':
                board[nr][nc] = 'B'
                stack.append((nr, nc))
    
    # 最终替换
    for r in range(rows):
        for c in range(cols):
            board[r][c] = 'O' if board[r][c] == 'B' else 'X'

迭代版DFS与BFS的实现非常相似，唯一的区别是使用栈（后进先出）而非队列（先进先出）。这种相似性也揭示了两种算法内在的统一性。

4. 算法对比与实战选择指南

4.1 时空复杂度分析

两种解法的时间复杂度都是O(M×N)，因为每个节点最多被访问一次。空间复杂度方面：

BFS：队列最大可能存储O(min(M,N))个节点（对角线传播时）
DFS递归：调用栈深度可能达到O(M×N)（极端情况下）
DFS迭代：显式栈与BFS队列类似

在实际应用中，BFS通常更适合：

寻找最短路径
图的层级遍历
避免递归深度过大

而DFS更适合：

拓扑排序
检测环路
需要回溯的问题

4.2 面试中的回答策略

当面试官要求解决这类矩阵遍历问题时，建议采取以下步骤：

明确问题要求，确认边界条件（如空矩阵处理）
提出逆向思维：从边界而非内部开始标记
先给出BFS/DFS中较熟悉的一种实现
主动分析时间/空间复杂度
提到另一种实现方式并比较优劣
讨论可能的优化（如union-find方法）

4.3 常见错误与调试技巧

无限循环：忘记标记已访问节点会导致重复访问。解决方法：在入队/入栈时立即标记。
边界条件遗漏：忘记处理空矩阵或单行/单列矩阵。解决方法：首先检查矩阵有效性。
方向处理错误：漏掉某个移动方向或数组越界。解决方法：使用directions数组并检查边界。
原地修改问题：直接在矩阵上修改可能导致逻辑混乱。解决方法：使用中间标记（如'B'）。

调试技巧：对于DFS问题，可以打印递归深度；对于BFS，可以打印每层的节点数。小矩阵（如3×3）是最佳的测试用例。

5. 问题变种与扩展思考

5.1 岛屿数量问题(LeetCode 200)的关联

被围绕的区域问题与岛屿数量问题有相似之处，都需要遍历矩阵中的连通区域。关键区别在于：

岛屿数量统计所有连通区域
被围绕的区域需要区分边界连通和完全包围的区域

理解这两个问题的异同有助于掌握矩阵遍历问题的核心模式。

5.2 Union-Find解法简介

虽然BFS/DFS是这类问题的标准解法，但Union-Find（并查集）也能提供有趣的视角：

虚拟一个"边界父节点"
将边界'O'与该节点连接
连接所有相邻的'O'
最后所有不与虚拟节点连接的'O'都被包围

这种解法在需要动态连接节点的场景中特别有用。

5.3 三维空间中的扩展

想象这个问题扩展到三维空间（如医学影像处理），我们需要标记被完全包围的空腔。这时：

BFS/DFS仍然适用，但方向从4个增加到6个（上下左右前后）
内存消耗成为更大挑战，可能需要分块处理
并行计算（如多线程BFS）可能带来性能提升

在实际工程中，这类算法常用于图像处理、CAD建模和科学计算领域。