LeetCode-DFS&BFS-130-M：被围绕的区域（Surrounded Regions）

给定一个二维的矩阵，包含 ‘X’ 和 ‘O’（字母 O）。
找到所有被 ‘X’ 围绕的区域，并将这些区域里所有的 ‘O’ 用 ‘X’ 填充。

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

Depth-first Search系列问题：

（1）LeetCode-Tree-98-M：验证二叉搜索树
（2）LeetCode-Tree-101-E：对称二叉树
（3）LeetCode-Tree-104-E：二叉树的最大深度
（4）LeetCode-Tree-105-M： 从前序与中序遍历序列构造二叉树
（5） LeetCode-Tree-108-E： 将有序数组转换为二叉搜索树
（6）LeetCode-Tree-116-M： 填充每个节点的下一个右侧节点指针
（7）LeetCode-Tree-124-H：二叉树中的最大路径和
（8）LeetCode-DFS-130-M：被围绕的区域（Surrounded Regions）
（9）…

思路

（1）参见：bfs+递归dfs+非递归dfs+并查集-胡明
（2）和边界是连通的情况时，为了记录这种状态，我们把这种情况下的 O换成 # 作为占位符，待搜索结束之后，遇到 O 替换为 X（和边界不连通的 O）；遇到 #，替换回 $O(和边界连通的 O)。

解法1

class Solution {
    public void solve(char[][] board) {
        if (board == null || board.length == 0) return;
        int m = board.length;
        int n = board[0].length;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                // 从边缘o开始搜索
                boolean isEdge = i == 0 || j == 0 || i == m - 1 || j == n - 1;
                if (isEdge && board[i][j] == 'O') {
                    dfs(board, i, j);
                }
            }
        }

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (board[i][j] == 'O') {
                    board[i][j] = 'X';
                }
                if (board[i][j] == '#') {
                    board[i][j] = 'O';
                }
            }
        }
    }

    public void dfs(char[][] board, int i, int j) {
        if (i < 0 || j < 0 || i >= board.length  || j >= board[0].length || board[i][j] == 'X' || board[i][j] == '#') {
            // board[i][j] == '#' 说明已经搜索过了. 
            return;
        }
        board[i][j] = '#';
        dfs(board, i - 1, j); // 上
        dfs(board, i + 1, j); // 下
        dfs(board, i, j - 1); // 左
        dfs(board, i, j + 1); // 右
    }
}

解法2

（1）思路上与解法1没有区别，在对四边轮廓处理时更加易懂。
时间复杂度 ：O(n^2)

执行用时 :2 ms, 在所有 Java 提交中击败了97.18%的用户
内存消耗 :41.1 MB, 在所有 Java 提交中击败了44.31%的用户

class Solution {
    public void solve(char[][] board) {
        
        if(board == null || board.length == 0){
            return ;
        }
        
        int row = board.length;
        int col = board[0].length;
        
        for(int i=0; i<row; i++){
            if(board[i][0] == 'O'){
                dfs(board, i, 0);
            }
            if(board[i][col-1] == 'O'){
                dfs(board, i, col-1);
            }
        }
        
        for(int j=0; j<col; j++){
            if(board[0][j] == 'O'){
                dfs(board, 0, j);
            }
            
            if(board[row-1][j] == 'O'){
                dfs(board, row-1, j);
            }
        }
        
        for(int i=0; i<board.length; i++){
            for(int j=0; j<board[0].length; j++){
                if(board[i][j]=='O'){
                    board[i][j]='X';
                }
                
                if(board[i][j]=='#'){
                    board[i][j]='O';
                }
            }
        }
        
    }
    
    public void dfs(char[][] board, int i, int j){
        if(i<0 || i>=board.length || j<0 || j>=board[0].length || board[i][j]!='O'){
            return ;
        }
        
        board[i][j] = '#';
        dfs(board, i+1, j);
        dfs(board, i-1, j);
        dfs(board, i, j+1);
        dfs(board, i, j-1);    
    }
}