【深度优先搜索】leetcode 130. 被围绕的区域

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]{为}^{\prime }{X}^{\prime }{或}^{\prime }{O}^{\prime }$

方法一：深度优先搜索

解题思路

本题给定的矩阵中有三种元素：

• 字母 X；
• 被字母 X 包围的字母 O；
• 没有被字母 X 包围的字母 O。

本题要求将所有被字母 X 包围的字母 O都变为字母 X ，但很难判断哪些 O 是被包围的，哪些 O 不是被包围的。

我的想法是把 $board$ 数组进行备份，然后找到被围绕的区域，将应该被替换成 ‘X’ 的下标保存下来，最后把原数组相应的下标位置上的 ‘O’ 替换成 ‘X’。

代码

class Solution {
public:
    int tag;
    const int dx[4] = {1, 0, -1, 0};
    const int dy[4] = {0, 1, 0, -1};
    vector<pair<int, int>> ans;
    void dfs(vector<vector<char>>& grid, int x, int y) {
        if(grid[x][y] == 'X')  return;
        grid[x][y] = 'X';
        ans.push_back({x, y});
        for(int i = 0; i < 4; i++) {
            int mx = x + dx[i], my = y + dy[i];
            if(mx >= 0 && mx < grid.size() && my >= 0 && my < grid[0].size()) {
                dfs(grid, mx, my);
            } else {
                tag = 0;
            }
        }
    } 
    void solve(vector<vector<char>>& board) {
        vector<vector<char>> grid(board);
        int nr = board.size(), nc = board[0].size();
        for(int r = 0; r < nr; r++)
            for(int c = 0; c < nc; c++)
                if(grid[r][c] == 'O') {
                    tag = 1;
                    dfs(grid, r, c);
                    if(tag) {
                        for(auto p: ans) {
                            board[p.first][p.second] = 'X';
                        }   
                    }
                    ans.clear();
                }
    }
};

复杂度分析

• 时间复杂度：$O(n\times m)$。
• 空间复杂度：$O(n\times m)$。

方法二：深度优先搜索（优化版）

解题思路

注意到题目解释中提到：任何边界上的 O 都不会被填充为 X。 我们可以想到，所有的不被包围的 O 都直接或间接与边界上的 O 相连。我们可以利用这个性质判断 O 是否在边界上，具体地说：

对于每一个边界上的 O，我们以它为起点，标记所有与它直接或间接相连的字母 O；
最后我们遍历这个矩阵，对于每一个字母：

• 如果该字母被标记过，则该字母为没有被字母 X 包围的字母 O，我们将其还原为字母 O；
• 如果该字母没有被标记过，则该字母为被字母 X 包围的字母 O，我们将其修改为字母 X。

代码

class Solution {
public:
    const int dx[4] = {1, 0, -1, 0};
    const int dy[4] = {0, 1, 0, -1};
    void dfs(vector<vector<char>>& grid, int x, int y) {
        if(grid[x][y] == 'A' || grid[x][y] == 'X')  return;
        grid[x][y] = 'A';
        for(int i = 0; i < 4; i++) {
            int mx = x + dx[i], my = y + dy[i];
            if(mx >= 0 && mx < grid.size() && my >= 0 && my < grid[0].size()) {
                dfs(grid, mx, my);
            }
        }
    } 
    void solve(vector<vector<char>>& board) {
        int nr = board.size(), nc = board[0].size();
        for(int i = 0; i < nc; i++) {
            dfs(board, 0, i);
            dfs(board, nr - 1, i);
        }
        for(int i = 0; i < nr; i++) {
            dfs(board, i, 0);
            dfs(board, i, nc - 1);
        }
        for(int r = 0; r < nr; r++)
            for(int c = 0; c < nc; c++) {
                if(board[r][c] == 'A') {
                    board[r][c] = 'O';
                } else if(board[r][c] == 'O') {
                    board[r][c] = 'X';
                }
            }
    }
};

复杂度分析

• 时间复杂度：$O(n\times m)$。
• 空间复杂度：$O(n\times m)$。