130. 被围绕的区域【 力扣(LeetCode) 】

零、LeetCode 原题

130. 被围绕的区域

一、题目描述

给你一个 m x n 的矩阵 board ，由若干字符 ‘X’ 和 ‘O’ 组成，捕获 所有 被围绕的区域：

• 连接：一个单元格与水平或垂直方向上相邻的单元格连接。
• 区域：连接所有 ‘O’ 的单元格来形成一个区域。
• 围绕：如果您可以用 ‘X’ 单元格 连接这个区域，并且区域中没有任何单元格位于 board 边缘，则该区域被 ‘X’ 单元格围绕。

通过将输入矩阵 board 中的所有 ‘O’ 替换为 ‘X’ 来 捕获被围绕的区域。

二、测试用例

示例 1：

输入：board = [["X","X","X","X"],["X","O","O","X"],["X","X","O","X"],["X","O","X","X"]]

输出：[["X","X","X","X"],["X","X","X","X"],["X","X","X","X"],["X","O","X","X"]]

解释：
在上图中，底部的区域没有被捕获，因为它在 board 的边缘并且不能被围绕。

示例 2：

输入：board = [["X"]]

输出：[["X"]]

提示：

m == board.length
n == board[i].length
1 <= m, n <= 200
board[i][j] 为 'X' 或 'O'

三、解题思路

1. 基本思路：
     这题本质上还是图的遍历，深度搜索和广度搜索都可以，关键在于如何存储一块 ‘O’ 区域和如何判断要不要将这块 ‘O’ 区域替换为 ‘X’ 。我的思路是，广度优先遍历；存储 O 区域其实只要保证每一次遍历的队列内都是不重复的 O 区域，然后不要弹出元素即可；判断是否要替换，则只要判断这块区域是否有元素处于边界即可，只要有一个元素处于边界，这块区域就不会被围绕。
2. 具体思路：
   • 遍历图的每个元素：
     • 判断是否被遍历过，是则跳过；
     • 判断是否为 X ，是则跳过；
     • 将该元素入队，同时初始化 k 与 flag ，其中 k 用于替代弹出队列操作，flag 用于标识是否要将该区域替换；
     • 广度优先遍历，遍历这一块的 O 区域；
     • 根据 flag 选择清空队列还是替换区域；

四、参考代码

时间复杂度：$\mathrm{O}(mn)$
空间复杂度：$\mathrm{O}(mn)$

class Solution {
public:
    void solve(vector<vector<char>>& board) {
        vector<pair<int, int>> dfs;
        int m = board.size();
        int n = board[0].size();
        vector<vector<bool>> used(m, vector<bool>(n, false));

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (used[i][j])
                    continue;
                used[i][j] = true;
                if (board[i][j] == 'X')
                    continue;
                dfs.emplace_back(i, j);
                int k = 0;
                bool flag = false;
                while (dfs.size() > k) {
                    const auto index = dfs[k];
                    k++;
                    if (index.first == 0 || index.first == m - 1 ||
                        index.second == 0 || index.second == n - 1) {
                        flag = true;
                    }
                    if (index.first > 0 &&
                        !used[index.first - 1][index.second] &&
                        board[index.first - 1][index.second] == 'O') {
                        used[index.first - 1][index.second] = true;
                        dfs.emplace_back(index.first - 1, index.second);
                    }
                    if (index.first + 1 < m &&
                        !used[index.first + 1][index.second] &&
                        board[index.first + 1][index.second] == 'O') {
                        used[index.first + 1][index.second] = true;
                        dfs.emplace_back(index.first + 1, index.second);
                    }
                    if (index.second > 0 &&
                        !used[index.first][index.second - 1] &&
                        board[index.first][index.second - 1] == 'O') {
                        used[index.first][index.second - 1] = true;
                        dfs.emplace_back(index.first, index.second - 1);
                    }
                    if (index.second + 1 < n &&
                        !used[index.first][index.second + 1] &&
                        board[index.first][index.second + 1] == 'O') {
                        used[index.first][index.second + 1] = true;
                        dfs.emplace_back(index.first, index.second + 1);
                    }
                }
                if (flag) {
                    dfs.clear();
                } else {
                    while (dfs.size()) {
                        const auto index = dfs.back();
                        board[index.first][index.second] = 'X';
                        dfs.pop_back();
                    }
                }
            }
        }
    }
};