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

---

[code]

public class Solution {
    public void solve(char[][] board) {
        if(board==null || board.length<3 || board[0].length<3)return;
        int m=board.length, n=board[0].length;
        for(int i=0;i<m;i++)if(board[i][0]=='O')bfs(board, i, 0);
        for(int i=0;i<m;i++)if(board[i][n-1]=='O')bfs(board, i, n-1);
        for(int j=0;j<n;j++)if(board[0][j]=='O')bfs(board, 0, j);
        for(int j=0;j<n;j++)if(board[m-1][j]=='O')bfs(board, m-1, j);
        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]=='T')board[i][j]='O';
            }
        }
    }

    void bfs(char[][] board, int row, int col)
    {
        if(row<0 || row>=board.length || col<0 || col>=board[0].length)return;
        ArrayList<int[]> queue=new ArrayList<int[]>();
        if(board[row][col]=='O')
        {
            board[row][col]='T';
            queue.add(new int[]{row, col});
        }
        while(queue.size()>0)
        {
            int n=queue.size();
            for(int k=0;k<n;k++)
            {
                int[] temp=queue.remove(0);
                int i=temp[0], j=temp[1];
                if(i>0 && board[i-1][j]=='O')
                {
                    board[i-1][j]='T';
                    queue.add(new int[]{i-1, j});
                }
                if(i<board.length-1 && board[i+1][j]=='O')
                {
                    board[i+1][j]='T';
                    queue.add(new int[]{i+1, j});
                }
                if(j>0 && board[i][j-1]=='O')
                {
                    board[i][j-1]='T';
                    queue.add(new int[]{i, j-1});
                }
                if(j<board[0].length-1 && board[i][j+1]=='O')
                {
                    board[i][j+1]='T';
                    queue.add(new int[]{i, j+1});
                }
            }
        }
    }
}

[Thoughts]
用dfs写递归版本，连续的O很多的事后会stack over flow.