Leetcode: 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

Use flood fill to fill 'O's on the four edges with '#'. Then replace all the rest 'O's with 'X's and then modify '#'s back to 'O's. When implementing flood fill, both depth first search and breadth first search can be used. But when using recursion to realize depth first search, stack may overflow for large board. So it's recommended to use a queue to implement breadth first search.

public class Solution {
    public void solve(char[][] board) {
        if (board == null || board.length <= 1 || board[0].length <= 1) {
            return;
        }
        
        for (int i = 0; i < board.length; i++) {
            floodFill(board, i, 0);
            floodFill(board, i, board[0].length - 1);
        }
        
        for (int i = 0; i < board[0].length; i++) {
            floodFill(board, 0, i);
            floodFill(board, board.length - 1, i);
        }
        
        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';
                } else if (board[i][j] == '#') {
                    board[i][j] = 'O';
                }
            }
        }
        
        return;
    }
    
    private void floodFill(char[][] board, int i, int j) {
        // if (i < 0 || i > board.length - 1 || j < 0 || j > board[0].length - 1 || board[i][j] != 'O') {
        //     return;
        // }
        
        // board[i][j] = '#';
        // floodFill(board, i - 1, j);
        // floodFill(board, i + 1, j);
        // floodFill(board, i, j - 1);
        // floodFill(board, i, j + 1);
        if (board[i][j] != 'O') {
            return;
        }
        
        board[i][j] = '#';
        Queue<Integer> queue = new LinkedList<Integer>();
        int code = i * board[0].length + j;
        queue.offer(code);
        while (!queue.isEmpty()) {
            code = queue.poll();
            int row = code / board[0].length;
            int col = code % board[0].length;
            if (row - 1 >= 0 && board[row - 1][col] == 'O') {
                board[row - 1][col] = '#';
                queue.offer((row - 1) * board[0].length + col);
            }
            if (row + 1 < board.length && board[row + 1][col] == 'O') {
                board[row + 1][col] = '#';
                queue.offer((row + 1) * board[0].length + col);
            }
            if (col - 1 >= 0 && board[row][col - 1] == 'O') {
                board[row][col - 1] = '#';
                queue.offer(row * board[0].length + col - 1);
            }
            if (col + 1 < board[0].length && board[row][col + 1] == 'O') {
                board[row][col + 1] = '#';
                queue.offer(row * board[0].length + col + 1);
            }
        }
    }
}