数组：围绕的区域

给定一个二维的矩阵，包含 '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'。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。

二维数组获取长度：board[][]

行：board.length

列：board[0].length

 

Dfs递归       X,O大写

public class Solution {
    public void solve(char[][] board) {

        if(board==null||board.length==0){//先判断是不是对象是的话再确定长度是不是为0
              return;
        }
        int row=board.length;//记录二维数组行
        int col=board[0].length;//记录二维数组列
        for(int i=0;i<row;i++){
           for(int j=0;j<col;j++){
                 //边界条件判断，边界还是o，需要递归
        boolean edge= (i==0 || j==0 ||i==row-1 || j==col-1);
                  if(edge && board[i][j]=='O'){
                      dfs(board,i,j);
                  }
            }
        }
        //全部递归之后，需要全局替换
        for(int i=0;i<row;i++){
            for(int j=0;j<col;j++){
                if(board[i][j]=='O'){ //如果是o,替换成x
                    board[i][j]='X';
                }               
                if(board[i][j]=='#'){//#作为占位符，代表不需要替换的o
                    board[i][j]='O';
                }
                
            }
        }
   }
//dfs递归
   public void dfs(char[][] board,int i,int j){
        //判断边界i,j是否满足条件，或者是#已经被访问过了，或者是x不需要递归
if(i<0 ||j<0 ||i>=board.length ||j>=board[0].length ||board[i][j]=='X'||board[i][j]=='#')
         return;
        
            board[i][j]='#';//递归的是边界且为o，所以用#作为占位符
              dfs(board,i-1,j);//上
              dfs(board,i+1,j);//下
              dfs(board,i,j-1);//左
              dfs(board,i,j+1);//右
   }
}

dfs非递归 （用栈记录状态）切忌大写

需要记录每一次遍历过的位置

import java.util.Stack;

public class Solution {
    //pos记录位置，内部类 Pos 来标记横坐标和纵坐标
    public class Pos{ //没有括号！！！
        int i;
        int j;
        Pos(int i,int j){
            this.i=i;
            this.j=j;
        }
    }
    public void solve(char[][] board) {
        if(board==null||board.length==0){//先判断是不是对象是的话再确定长度是不是为0
              return;
        }
        int row=board.length;//记录二维数组行
        int col=board[0].length;//记录二维数组列
        for(int i=0;i<row;i++){
           for(int j=0;j<col;j++){
                 //边界条件判断，边界还是o，需要递归
                  boolean edge= i==0 || j==0 ||i==row-1 || j==col-1;
                  if(edge && board[i][j]=='O'){
                      dfs(board,i,j);
                  }
            }
        }
        //全部递归之后，需要全局替换
        for(int i=0;i<row;i++){
            for(int j=0;j<col;j++){
                if(board[i][j]=='O'){ //如果是o,替换成x
                    board[i][j]='X';
                }
                if(board[i][j]=='#'){//#作为占位符，代表不需要替换的o
                    board[i][j]='O';
                }
            }
        }
   }
    //dfs非递归
   public void dfs(char[][] board,int i,int j){
        Stack<Pos> stack =new Stack<>();
        //将其入栈
        stack.push(new Pos(i,j));
        //需要递归的设置成#,占位符
        board[i][j]='#';
        while(!stack.isEmpty()){
            Pos temp =stack.peek();//记录栈顶 不需要出战
            //上
             if(temp.i-1>=0 &&  board[temp.i-1][temp.j]=='O' ){
                 //将该点入栈，并设置为#
                 stack.push(new Pos(temp.i-1,temp.j));
                 board[temp.i-1][temp.j]='#';
                 continue;
             }
            //下
            if(temp.i+1<=board.length-1 &&  board[temp.i+1][temp.j]=='O' ){
                //将该点入栈，并设置为#
                stack.push(new Pos(temp.i+1,temp.j));
                board[temp.i+1][temp.j]='#';
                continue;
            }
            //左
            if(temp.j-1>=0 &&  board[temp.i][temp.j-1]=='O' ){
                //将该点入栈，并设置为#
                stack.push(new Pos(temp.i,temp.j-1));
                board[temp.i][temp.j-1]='#';
                continue;
            }
            //右
            if(temp.j+1<=board[0].length-1 &&  board[temp.i][temp.j+1]=='O' ){
                //将该点入栈，并设置为#
                stack.push(new Pos(temp.i,temp.j+1));
                board[temp.i][temp.j+1]='#';
                continue;
            }
            // 如果上下左右都搜索不到,本次搜索结束，弹出stack
            stack.pop();
        }
   }
}

bfs非递归   （队列来记录状态）

//只要搜索到一个满足条件，我们就顺着该方向继续搜索，

我们要把上下左右满足条件的都入队，所以搜索的时候就不能 continue

import java.util.LinkedList;
public class Solution {
    //pos记录位置，内部类 Pos 来标记横坐标和纵坐标
    public class Pos{
        int i;
        int j;
        Pos(int i,int j){
            this.i=i;
            this.j=j;
        }
    }
    public void solve(char[][] board) {
        if(board==null||board.length==0){//先判断是不是对象是的话再确定长度是不是为0
              return;
        }
        int row=board.length;//记录二维数组行
        int col=board[0].length;//记录二维数组列
        for(int i=0;i<row;i++){
           for(int j=0;j<col;j++){
                 //边界条件判断，边界还是o，需要递归
                  boolean edge= i==0 || j==0 ||i==row-1 || j==col-1;
                  if(edge && board[i][j]=='O'){
                      dfs(board,i,j);
                  }
            }
        }
        //全部递归之后，需要全局替换
        for(int i=0;i<row;i++){
            for(int j=0;j<col;j++){
                if(board[i][j]=='O'){ //如果是o,替换成x
                    board[i][j]='X';
                }
                if(board[i][j]=='#'){//#作为占位符，代表不需要替换的o
                    board[i][j]='O';
                }
            }
        }
   }
    //bfs非递归
   public void dfs(char[][] board,int i,int j){
        //Stack<Pos> stack =new Stack<>();
        LinkedList<Pos> queue=new LinkedList<>();//队列
        //将其入队
        queue.add(new Pos(i,j)); 
        //需要递归的设置成#,占位符
        board[i][j]='#';
        while(!queue.isEmpty()){
            Pos temp =queue.poll();//出队
            //上
             if(temp.i-1>=0 &&  board[temp.i-1][temp.j]=='O' ){
                 //将该点入栈，并设置为#
                 queue.add(new Pos(temp.i-1,temp.j));
                 board[temp.i-1][temp.j]='#';
                 //continue;    //不需要只要有一个满足条件即可
             }
            //下
            if(temp.i+1<=board.length-1 &&  board[temp.i+1][temp.j]=='O' ){
                //将该点入栈，并设置为#
                queue.add(new Pos(temp.i+1,temp.j));
                board[temp.i+1][temp.j]='#';
               // continue;
            }
            //左
            if(temp.j-1>=0 &&  board[temp.i][temp.j-1]=='O' ){
                //将该点入栈，并设置为#
                queue.add(new Pos(temp.i,temp.j-1));
                board[temp.i][temp.j-1]='#';
                //continue;
            }
            //右
            if(temp.j+1<=board[0].length-1 &&  board[temp.i][temp.j+1]=='O' ){
                //将该点入栈，并设置为#
                queue.add(new Pos(temp.i,temp.j+1));
                board[temp.i][temp.j+1]='#';
                //continue;
            }
            // 如果上下左右都搜索不到,本次搜索结束，弹出stack
            //stack.pop();
        }
   }
}