[leetcode]Surrounded Regions

Surrounded Regions

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

算法思路：由外向内扫描，因为边界的O肯定是escape的，这样由边界往里面纵深查找出没有被capture的O

思路1：dfs，第一次居然过了，然后就再也过不去了，试想一个矩阵是100* 100并且全是O，如果dfs的话，就会有10000层，栈空间都溢出了....

思路2：BFS，大数据无压力过

代码如下：

public class Solution {
public void solve(char[][] board) {
        if(board == null || board.length == 0 ) return;
        int height = board.length;
        int width = board[0].length;
        int code = Math.max(height, width);
        for(int i = 0; i < height; i++){
            for(int j = 0; j < width; j++){
                if(board[i][j] == 'O' && (i == 0 || i == height - 1 || j == 0 || j == width - 1)){
                    board[i][j] = '@';
                    bfs(board, height, width, i, j, code);
                }
            }
        }
        for(int i = 0; i < height; i++){
            for(int j = 0; j < width; j++){
                if(board[i][j] == 'O'){
                    board[i][j] = 'X';
                }else if(board[i][j] == '@'){
                    board[i][j] = 'O';
                }
            }
        }
    }
    int[][] dir = {{-1,0},{1,0},{0,1},{0,-1}};
    private void bfs(char[][] board,int height,int width,int i ,int j,int code){
        Queue<Integer> q = new LinkedList<Integer>();
        q.offer(i * code + j);//将二维下标压缩成一维，方便存储
        while(!q.isEmpty()){
            int tem = q.poll();
            int row = tem / code;
            int col = tem % code;
            for(int k = 0;k < dir.length; k++){
                if(row + dir[k][0] < height && row + dir[k][0] >= 0 && col + dir[k][1] < width && col + dir[k][1] >= 0){
                    if(board[row + dir[k][0]][col + dir[k][1]] == 'O'){
                        board[row + dir[k][0]][col + dir[k][1]] = '@';
                        q.offer((row + dir[k][0]) * code + col + dir[k][1]);
                    }
                }
            }
        }
    }
}

坐标压缩法很有意思。