[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

观察实际上能够联通到边界‘O'的点是没有被’X'包围的点。

实际上我们DFS可以从边界开始，以边界为开始DFS的点就是没有被包围的点。

特别注意DFS的递归层数可能太多，不通过RuntimeError。对递归做一个小的修整可以解决这个问题。［这个题目的本意是让用BFS来做］

DFS：

class Solution {
public:
    void solve(vector<vector<char>>& board) {
      int m = board.size();
      if(m==0)
        return;
      int n = board[0].size();
      for(int i=0; i<m; ++i){
          if(board[i][0]=='O') dfs(board,i,0);
          if(board[i][n-1]=='O') dfs(board,i,n-1);
      }
      for(int j=0; j<n; ++j){
          if(board[0][j]=='O') dfs(board,0,j);
          if(board[m-1][j] =='O') dfs(board,m-1,j);
      } //从边界开始DFS能够到达的点说明不可以被围住，不能到达的点可以被围住
      for(int i=0; i<m; ++i){
          for(int j=0; j<n; ++j){
              if(board[i][j]=='V') board[i][j]='O';
              else if(board[i][j]=='O') board[i][j]='X';
          }
      }
    }
    void dfs(vector<vector<char>> &board,int row,int col){
            board[row][col]='V';
            int height = board.size();
            int width = board[0].size();
           if (row > 1 && board[row - 1][col] == 'O') dfs(board, row - 1, col);  // prevent stack overflow error
           if (row < height - 2 && board[row + 1][col] == 'O')dfs(board, row + 1, col);
           if (col > 1 && board[row][col - 1] == 'O') dfs(board, row, col - 1);
           if (col < width - 2 && board[row][col + 1] == 'O') dfs(board, row, col + 1);
    }
};

BFS：

class Solution {
public:
    void solve(vector<vector<char>>& board) {
      int m = board.size();
      if(m==0)
        return;
      int n = board[0].size();
      for(int i=0; i<m; ++i){
          if(board[i][0]=='O') bfs(board,i,0);
          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);
          if(board[m-1][j] =='O') bfs(board,m-1,j);
      } //从边界开始BFS能够到达的点说明不可以被围住，不能到达的点可以被围住
      for(int i=0; i<m; ++i){
          for(int j=0; j<n; ++j){
              if(board[i][j]=='V') board[i][j]='O';
              else if(board[i][j]=='O') board[i][j]='X';
          }
      }
    }
    void bfs(vector<vector<char>> &board,int row,int col){
            board[row][col]='V';
            queue<pair<int,int>> Queue;
            Queue.push(pair<int,int>(row,col));//队列表示BFS流程
            int height = board.size();
            int width = board[0].size();
            while(!Queue.empty()){
                pair<int,int> top;
                top = Queue.front();
                Queue.pop();
                int x = top.first;
                int y = top.second;
                if(x>1&&board[x-1][y]=='O'){
                    board[x-1][y]='V';
                    Queue.push(pair<int,int>(x-1,y));
                }
                if(x<height-2&&board[x+1][y]=='O'){
                    board[x+1][y]='V';
                    Queue.push(pair<int,int>(x+1,y));
                }
                if(y>1&&board[x][y-1]=='O'){
                    board[x][y-1]='V';
                    Queue.push(pair<int,int>(x,y-1));
                }
                if(y<width-2&&board[x][y+1]=='O'){
                    board[x][y+1]='V';
                    Queue.push(pair<int,int>(x,y+1));
                }    
            }
            
    }
};