BFS、DFS——surrounded-regions矩阵包围XXOO

题目描述

Given a 2D board containing'X'and'O', capture all regions surrounded by'X'.

A region is captured by flipping all'O's into'X's in that surrounded region .

For example,

X X X X
X O O X
X X O X
X O X X

After running your function, the board should be:

X X X X
X X X X
X X X X
X O X X

总的来说都可以归结为一个连通性的问题，用BFS；

1.在最外面一圈的O挨着的O肯定最后不是被包围的，与这个O也相连的也不能被包围，即这些O在最后的矩阵里面还是O；

2.从最外面一圈的O出发，用BFS，利用队列帮助进行扩展，将所有它能联通到的O都标记，

3.随后再扫描一遍矩阵，被标记的改回O,没有被标记的O都是可以被包围的，所以要改成X；

DFS:

    1.把矩阵边界连通的O全部找到，其余的O改为X
    2.起始顶点为所有边界O的坐标
    3.flag[i][j]标志O是否已经走过，若使用flag标记，则使用了O（m*n）的额外空间复杂度，所以把走过的标记为V
    4.邻接点为上下左右且符合要求的O.

public class Solution {
    //1.把矩阵边界连通的O全部找到，其余的O改为X
    //2.起始顶点为所有边界O的坐标
    //3.flag[i][j]标志O是否已经走过，若使用flag标记，则使用了O（m*n）的额外空间复杂度，所以把走过的标记为V
    //4.邻接点为上下左右且符合要求的O
    public void solve(char[][] board) {
        if(board == null||board.length == 0||board[0].length == 0){
            return ;
        }
        int rows=board.length;
        int cols=board[0].length;
        for(int i=0;i<rows;i++){
            if(board[i][0] == 'O'){
                dfs(board,rows,cols,i,0);
            }
            if(board[i][cols-1] == 'O'){
                dfs(board,rows,cols,i,cols-1);
            }
        }
        for(int j=0;j<cols;j++){
            if(board[0][j] == 'O'){
                dfs(board,rows,cols,0,j);
            }
            if(board[rows-1][j] == 'O'){
                dfs(board,rows,cols,rows-1,j);
            }
        }
        fillXO(board);
    }
    public void dfs(char[][] board,int rows,int cols,int i,int j){
        if(i < 0||i == rows||j < 0||j == cols||board[i][j] == 'X'||board[i][j] == 'V')
            return;
        board[i][j]='V';
        dfs(board,rows,cols,i-1,j);
        dfs(board,rows,cols,i+1,j);
        dfs(board,rows,cols,i,j-1);
        dfs(board,rows,cols,i,j+1);
    }
    public void fillXO(char[][] board){
        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] == 'V'){
                    board[i][j] = 'O';
                }
            }
        }
    }
}

BFS：

 1.把矩阵边界连通的O全部找到，其余的O改为X
 2.起始顶点为所有边界O的坐标，将所有起始点保存至队列中，并将相应位置置为'v'.
 3.队列中保存左边(x,y)的Pair。
 4.邻接点为上下左右且符合要求的O.

import java.util.*;
public class Solution {
    public void solve(char[][] board) {
        if(board == null||board.length == 0||board[0].length == 0)
            return ;
        int rows=board.length;
        int cols=board[0].length;
        LinkedList<Pair> list=new LinkedList();
        for(int i=0;i<rows;i++){
            if(board[i][0] == 'O'){
                list.add(new Pair(i,0));
                board[i][0]='V';
            }
            if(board[i][cols-1] == 'O'){
                list.add(new Pair(i,cols-1));
                board[i][cols-1]='V';
            }
        }
        for(int j=0;j<cols;j++){
            if(board[0][j] == 'O'){
                list.add(new Pair(0,j));
                board[0][j]='V';
            }
            if(board[rows-1][j] == 'O'){
                list.add(new Pair(rows-1,j));
                board[rows-1][j]='V';
            }
        }
        while(list.size()!=0){
            Pair pair=list.pollFirst();
            int x=pair.x;
            int y=pair.y;
            if(is_valid(board,rows,cols,x-1,y)){
                list.add(new Pair(x-1,y));
                board[x-1][y]='V';
            }
            if(is_valid(board,rows,cols,x+1,y)){
                list.add(new Pair(x+1,y));
                board[x+1][y]='V';
            }
            if(is_valid(board,rows,cols,x,y-1)){
                list.add(new Pair(x,y-1));
                board[x][y-1]='V';
            }
            if(is_valid(board,rows,cols,x,y+1)){
                list.add(new Pair(x,y+1));
                board[x][y+1]='V';
            }
        }
        fillXO(board);
    }
    public boolean is_valid(char[][] board,int rows,int cols,int i,int j){
        if(i < 0||i == rows||j < 0||j == cols||board[i][j] == 'X'||board[i][j] == 'V'){
            return false;
        }else{
            return true;
        }
    }
     public void fillXO(char[][] board){
        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] == 'V'){
                    board[i][j] = 'O';
                }
            }
        }
    }
    class Pair{
        int x;
        int y;
        public Pair(int x,int y){
            this.x=x;
            this.y=y;
        }
    }
}