lc_dfs_130_surroundByX

题目：被围绕的区域 middle
给定一个二维的矩阵，包含 '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

解释:
 被围绕的区间不会存在于边界上，换句话说，任何边界上的 'O' 都不会被填充为 'X'。
 任何不在边界上，或不与边界上的 'O' 相连的 'O' 最终都会被填充为 'X'。
 如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。

 

思路：
    这道题我们拿到基本就可以确定是图的 dfs、bfs 遍历的题目了。
    题目中解释说被包围的区间不会存在于边界上，所以我们会想到边界上的O要特殊处理，
只要把边界上的 O 特殊处理了，那么剩下的 O 替换成 X 就可以了。
    问题转化为，如何寻找和边界联通的 O，我们需要考虑如下情况。
    X X X X
    X O O X
    X X O X
    X O O X
    这时候的 O 是不做替换的。因为和边界是连通的。为了记录这种状态，
我们把这种情况下的O换成 # 作为占位符，待搜索结束之后，遇到 O 替换为 X（和边界不连通的O）；
遇到 #，替换回 O(和边界连通的 O)。

    如何寻找和边界联通的O? 从边界出发，对图进行 dfs 和 bfs 即可。这里简单总结下 dfs 和 bfs。

   

    1.bfs 递归。可以想想二叉树中如何递归的进行层序遍历。
    2.bfs 非递归。一般用队列存储。方法2采用了bfs非递归
    3.dfs 递归。最常用，如二叉树的先序遍历。方法1采用dfs递归
    4.dfs 非递归。一般用 stack。

package leetCode.DFS;

public class lc_dfs_130_surroundByX {

    
    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);
                    bfs(board, i, j);
                }
            }
        }

//        替换，将与边缘的'O'联通的'O'(已在dfs中替换为'#'),替换为'O'，将其余'O'替换为'X'
        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';
                }
            }
        }

    }


    /**
     * dfs,只要搜索到一个满足条件，就顺着该方向继续搜索，不必等待该点的4个方向都搜索完
     */
    public void dfs(char[][] board, int i, int j) {
        // board[i][j] != 'O'包括'#'和'X','#' 说明已经搜索过了,'X'不是目标
        if (i < 0 || j < 0 || i >= board.length || 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);// 右

    }

    /**
     * bfs非递归，每个符合的点都要将4个方向搜索完才能进行下一个点的搜索
     */

    public void bfs(char[][] board, int row, int col) {
        board[row][col] = '#';
        LinkedList<Integer> x = new LinkedList<>();//记录符合点的横坐标
        LinkedList<Integer> y = new LinkedList<>();//记录符合点的纵坐标
        int[] xx = {1, 0, -1, 0};//上下左右四个方向
        int[] yy = {0, 1, 0, -1};
        x.offer(row);//先将本点放入队列中
        y.offer(col);
        while (!x.isEmpty()) {
            //从四个方向搜索与本点相通的'O'
            for (int i = 0; i < 4; i++) {
                int drow = x.peek() + xx[i];
                int dcol = y.peek() + yy[i];
//                符合条件就入队并赋值'#'
                if (drow >= 0 && drow < board.length && dcol >= 0 && dcol < board[0].length
                        && board[drow][dcol] == 'O') {
                    //搜索到就将其放入队列中并设置为'#'
                    x.offer(drow);
                    y.offer(dcol);
                    board[drow][dcol] = '#';
                }
            }
//  四个方向搜索完才将其弹出，也可以在4方向搜索前就弹出，并记录下该点的横纵坐标，
// 不过要新建变量，占内存，所以放在后面弹出
            x.poll();
            y.poll();
        }

    }
}