力扣130题：被围绕区域的DFS/BFS与并查集解法-代码聚汇网

力扣130题：被围绕区域的DFS/BFS与并查集解法

胖厨胡学斌

1. 题目背景与核心挑战

力扣130题"被围绕的区域"是一个经典的图遍历问题，题目要求我们将二维矩阵中所有被'X'完全包围的'O'区域替换为'X'。这个看似简单的问题实际上考察了以下几个关键能力：

对二维矩阵的遍历技巧
深度优先搜索(DFS)或广度优先搜索(BFS)的应用
边界条件的处理能力
空间复杂度的优化意识

我第一次遇到这个问题时，直观的想法是从每个'O'出发，检查它是否被'X'完全包围。但很快发现这种暴力解法的时间复杂度会达到O(n^4)，对于较大的矩阵完全不实用。

2. 解题思路的演进过程

2.1 初始暴力解法及其缺陷

最直接的思路是对矩阵中的每个'O'进行DFS/BFS，检查它能否到达边界：

python复制def solve(board):
    if not board:
        return
    
    m, n = len(board), len(board[0])
    
    def is_surrounded(i, j):
        visited = [[False]*n for _ in range(m)]
        stack = [(i, j)]
        visited[i][j] = True
        surrounded = True
        
        while stack:
            x, y = stack.pop()
            if x == 0 or x == m-1 or y == 0 or y == n-1:
                surrounded = False
            
            for dx, dy in [(-1,0),(1,0),(0,-1),(0,1)]:
                nx, ny = x + dx, y + dy
                if 0 <= nx < m and 0 <= ny < n and not visited[nx][ny] and board[nx][ny] == 'O':
                    visited[nx][ny] = True
                    stack.append((nx, ny))
        
        return surrounded
    
    for i in range(m):
        for j in range(n):
            if board[i][j] == 'O' and is_surrounded(i, j):
                board[i][j] = 'X'

这个解法的问题在于：

重复计算：同一个'O'可能被多次访问
时间复杂度高：最坏情况下O((mn)^2)
空间复杂度高：每次DFS都需要新的visited数组

2.2 逆向思维：从边界出发

更聪明的做法是从边界上的'O'出发，标记所有与之相连的'O'。这些'O'是不被包围的，最后只需要将未被标记的'O'改为'X'即可。

python复制def solve(board):
    if not board:
        return
    
    m, n = len(board), len(board[0])
    
    # 标记与边界'O'相连的区域
    def dfs(i, j):
        if 0 <= i < m and 0 <= j < n and board[i][j] == 'O':
            board[i][j] = 'T'  # 临时标记
            dfs(i+1, j)
            dfs(i-1, j)
            dfs(i, j+1)
            dfs(i, j-1)
    
    # 处理四条边
    for i in range(m):
        dfs(i, 0)
        dfs(i, n-1)
    for j in range(n):
        dfs(0, j)
        dfs(m-1, j)
    
    # 替换标记
    for i in range(m):
        for j in range(n):
            if board[i][j] == 'O':
                board[i][j] = 'X'
            elif board[i][j] == 'T':
                board[i][j] = 'O'

这个解法的时间复杂度降到了O(mn)，空间复杂度在最坏情况下(递归深度)也是O(mn)，但可以通过迭代方式优化。

2.3 BFS迭代实现

对于大规模矩阵，递归可能导致栈溢出。我们可以用BFS的迭代实现：

python复制from collections import deque

def solve(board):
    if not board:
        return
    
    m, n = len(board), len(board[0])
    queue = deque()
    
    # 将边界'O'加入队列
    for i in range(m):
        if board[i][0] == 'O':
            queue.append((i, 0))
        if board[i][n-1] == 'O':
            queue.append((i, n-1))
    for j in range(n):
        if board[0][j] == 'O':
            queue.append((0, j))
        if board[m-1][j] == 'O':
            queue.append((m-1, j))
    
    # BFS标记
    while queue:
        i, j = queue.popleft()
        if 0 <= i < m and 0 <= j < n and board[i][j] == 'O':
            board[i][j] = 'T'
            queue.append((i+1, j))
            queue.append((i-1, j))
            queue.append((i, j+1))
            queue.append((i, j-1))
    
    # 替换标记
    for i in range(m):
        for j in range(n):
            if board[i][j] == 'O':
                board[i][j] = 'X'
            elif board[i][j] == 'T':
                board[i][j] = 'O'

3. 算法优化与空间复杂度分析

3.1 空间复杂度优化

上述解法中，我们使用了额外的标记'T'，实际上可以原地修改而不需要额外空间：

python复制def solve(board):
    if not board:
        return
    
    m, n = len(board), len(board[0])
    
    def dfs(i, j):
        if 0 <= i < m and 0 <= j < n and board[i][j] == 'O':
            board[i][j] = '#'  # 使用特殊字符标记
            dfs(i+1, j)
            dfs(i-1, j)
            dfs(i, j+1)
            dfs(i, j-1)
    
    for i in range(m):
        dfs(i, 0)
        dfs(i, n-1)
    for j in range(n):
        dfs(0, j)
        dfs(m-1, j)
    
    for i in range(m):
        for j in range(n):
            if board[i][j] == 'O':
                board[i][j] = 'X'
            elif board[i][j] == '#':
                board[i][j] = 'O'

3.2 并查集解法

另一种思路是使用并查集(Union-Find)数据结构，将边界'O'连接到一个虚拟节点，最后检查每个'O'是否与虚拟节点相连：

python复制class UnionFind:
    def __init__(self, n):
        self.parent = list(range(n))
    
    def find(self, x):
        while self.parent[x] != x:
            self.parent[x] = self.parent[self.parent[x]]  # 路径压缩
            x = self.parent[x]
        return x
    
    def union(self, x, y):
        root_x = self.find(x)
        root_y = self.find(y)
        if root_x != root_y:
            self.parent[root_x] = root_y

def solve(board):
    if not board:
        return
    
    m, n = len(board), len(board[0])
    uf = UnionFind(m * n + 1)
    dummy = m * n  # 虚拟节点
    
    for i in range(m):
        for j in range(n):
            if board[i][j] == 'O':
                if i == 0 or i == m-1 or j == 0 or j == n-1:
                    uf.union(i * n + j, dummy)
                else:
                    for di, dj in [(-1,0),(1,0),(0,-1),(0,1)]:
                        ni, nj = i + di, j + dj
                        if 0 <= ni < m and 0 <= nj < n and board[ni][nj] == 'O':
                            uf.union(i * n + j, ni * n + nj)
    
    for i in range(m):
        for j in range(n):
            if board[i][j] == 'O' and uf.find(i * n + j) != uf.find(dummy):
                board[i][j] = 'X'

并查集解法的时间复杂度接近O(mn)，但实际运行效率可能不如DFS/BFS，因为并查集操作有额外的常数因子。

4. 实际编码中的注意事项

4.1 边界条件处理

空输入检查：必须首先检查board是否为空
单行/单列矩阵：需要特殊处理
极小矩阵：如1x1或2x2的情况

4.2 递归深度问题

对于非常大的矩阵，递归实现的DFS可能导致栈溢出。Python默认递归深度限制约为1000，对于200x200的矩阵就可能出现问题。解决方案：

使用迭代实现的DFS/BFS

调整递归深度限制（不推荐）

python复制import sys
sys.setrecursionlimit(100000)

4.3 方向数组的使用技巧

在DFS/BFS中，处理四个方向时可以使用方向数组简化代码：

python复制directions = [(-1,0),(1,0),(0,-1),(0,1)]  # 上、下、左、右

for di, dj in directions:
    ni, nj = i + di, j + dj
    # 处理新坐标

4.4 标记方法的选择

标记方法有多种选择，各有优缺点：

使用特殊字符（如'T'、'#'）：
- 优点：不需要额外空间
- 缺点：可能与被允许的字符冲突（虽然本题中只有'X'和'O'）
使用额外的visited数组：
- 优点：不影响原数据
- 缺点：需要O(mn)额外空间
修改原数据后恢复：
- 优点：空间最优
- 缺点：需要确保恢复逻辑正确

5. 复杂度对比与选择建议

方法	时间复杂度	空间复杂度	适用场景
暴力DFS	O((mn)^2)	O(mn)	不推荐
边界DFS	O(mn)	O(mn)递归栈	中等规模矩阵
边界BFS	O(mn)	O(min(m,n))队列	大规模矩阵
并查集	O(mnα(mn))	O(mn)	需要连接性信息的场景

选择建议：

面试中：推荐边界DFS/BFS，代码简洁易懂
竞赛中：BFS迭代实现更可靠
生产环境：根据矩阵大小选择，极大矩阵考虑BFS或并查集

6. 变种问题与扩展思考

6.1 统计被围绕的区域数量

修改题目要求统计被围绕的'O'区域数量，而非修改它们。解法只需稍作调整：

python复制def countSurroundedRegions(board):
    if not board:
        return 0
    
    m, n = len(board), len(board[0])
    count = 0
    
    def dfs(i, j):
        nonlocal is_surrounded
        if i < 0 or i >= m or j < 0 or j >= n:
            is_surrounded = False
            return
        if board[i][j] != 'O':
            return
        board[i][j] = 'T'  # 标记已访问
        dfs(i+1, j)
        dfs(i-1, j)
        dfs(i, j+1)
        dfs(i, j-1)
    
    for i in range(m):
        for j in range(n):
            if board[i][j] == 'O':
                is_surrounded = True
                dfs(i, j)
                if is_surrounded:
                    count += 1
                # 恢复标记
                dfs_restore(i, j)
    
    return count

6.2 三维矩阵中的被围绕区域

如果问题扩展到三维空间，基本思路相同，但需要考虑6个方向（上下左右前后）和更多的边界条件。

6.3 动态变化的矩阵

如果矩阵会动态变化（某些'X'变为'O'或反之），并需要频繁查询被围绕区域，可以考虑使用并查集配合懒惰更新策略。

7. 面试技巧与常见问题

7.1 面试官可能追问的问题

如何证明你的算法是正确的？
- 解释所有不被包围的'O'都与边界相连
- 说明算法会标记所有这些'O'
如何处理环形包围的情况？
- 示例：外层'O'包围内层'O'，内层'O'又被'X'包围
- 解释算法仍然有效，因为内层'O'不与边界相连
如果矩阵非常大无法放入内存怎么办？
- 讨论分块处理策略
- 考虑使用外部排序或流式处理

7.2 白板编码技巧

先写出暴力解法，再优化
明确说明时间和空间复杂度
画出小例子演示算法流程
主动讨论边界条件

7.3 代码风格建议

使用有意义的变量名（如rows/cols而非m/n）
提取方向数组等常量
添加简要注释说明关键步骤
保持一致的缩进和代码风格

8. 实际工程中的应用场景

虽然这个问题看起来是纯算法题，但其核心思想在许多实际场景中有应用：

图像处理中的连通区域分析
游戏开发中的地图区域检测
电路设计中的绝缘区域检查
地理信息系统中的封闭区域识别

理解这个问题的解法可以帮助我们处理这些实际工程问题。例如，在图像处理中，我们可能需要找出所有被特定颜色完全包围的区域，这与本题非常相似。