130. 被围绕的区域(多源BFS)

130. 被围绕的区域

给你一个 m x n 的矩阵 board ，由若干字符 'X' 和 'O' ，找到所有被 'X' 围绕的区域，并将这些区域里所有的 '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"]]
解释：被围绕的区间不会存在于边界上，换句话说，任何边界上的 'O' 都不会被填充为 'X'。 任何不在边界上，或不与边界上的 'O' 相连的 'O' 最终都会被填充为 'X'。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。

示例 2：

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

 

提示：

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

class Solution {
public:
    static constexpr int g_directions[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
    // 判定是否越界
    bool isInArea(int x, int y) {
        return (x >= 0 && x < row && y >= 0 && y < col);
    }
    // 将边界'O'入队并设置为已访问
    void addEdgeToQueue(vector<vector<char>> &board, vector<vector<bool>> &visited, 
        queue<std::pair<int, int>> &q) {
        for (int i = 0; i < row; i++) {
            if (board[i][0] == 'O') {
                q.push({i, 0});
                visited[i][0] = true;
            }
            if (board[i][col - 1] == 'O') {
                q.push({i, col - 1});
                visited[i][col - 1] = true;
            }
        }
        for (int j = 1; j < col - 1; j++) {
            if (board[0][j] == 'O') {
                q.push({0, j});
                visited[0][j] = true;
            }
            if (board[row - 1][j] == 'O') {
                q.push({row - 1, j});
                visited[row - 1][j] = true;
            }
        }        
    }
    // 将与边界连通的'O'方格标记为已访问
    void bfs(vector<vector<char>> &board, vector<vector<bool>> &visited, queue<std::pair<int, int>> &q) {
        while (!q.empty()) {
            int size = q.size();
            for (int i = 0; i < size; i++) {
                auto [curX, curY] = q.front();
                q.pop();
                for (auto &direction : g_directions) {
                    int nextX = direction[0] + curX;
                    int nextY = direction[1] + curY;
                    if (!isInArea(nextX, nextY) || visited[nextX][nextY]) {
                        continue;
                    }
                    if (board[nextX][nextY] == 'O') {
                        q.push({nextX, nextY});
                        visited[nextX][nextY] = true;
                    }
                } 
            }
        }
    }
    void solve(vector<vector<char>>& board) {
        row = board.size();
        col = board[0].size();
        queue<std::pair<int, int>> q;
        vector<vector<bool>> visited(row, vector<bool>(col, false));
        // 将边界'O'坐标入队
        addEdgeToQueue(board, visited, q);
        // 将与边界'O'相连的'O'标记为已访问
        bfs(board, visited, q);
        // 遍历非边界矩阵元素,将未访问的'O'修改成'X'
        for (int i = 1; i < row - 1; i++) {
            for (int j = 1; j < col - 1; j++) {
                if (board[i][j] == 'O' && !visited[i][j]) {
                    board[i][j] = 'X';
                }
            }
        }
    }
private:
    int row;
    int col;
};