【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

 

 

用dfs试试，大数据时递归会溢出

 class Solution {
 public:
     void solve(vector<vector<char>> &board) {
         int m=board.size();
         if(m==) return;
         int n=board[].size();

         vector<vector<bool>> visited(m,vector<bool>(n,false));
         for(int i=;i<m;i++)
         {
             if(board[i][]=='O'&&!visited[i][])
             {
                 dfs(board,visited,i,,m,n);
             }

             if(board[i][n-]=='O'&&!visited[i][n-])
             {
                 dfs(board,visited,i,n-,m,n);
             }
         }

         for(int j=;j<n;j++)
         {

             if(board[][j]=='O'&&!visited[][j])
             {
                 dfs(board,visited,,j,m,n);
             }

             if(board[m-][j]=='O'&&!visited[m-][j])
             {
                 dfs(board,visited,m-,j,m,n);
             }

         }

         for(int i=;i<m;i++)
         {
             for(int j=;j<n;j++)
             {
                 if(board[i][j]=='O'&&visited[i][j])
                 {
                     board[i][j]='X';
                 }
             }
         }

         return;
     }

     void dfs(vector<vector<char>> &board,vector<vector<bool>> &visited,int i,int j,int &m,int &n)
     {
         if(board[i][j]=='O')
         {
             visited[i][j]=true;
             if(i+<m&&visited[i+][j]==false)dfs(board,visited,i+,j,m,n);
             if(j+<n&&visited[i][j+]==false)dfs(board,visited,i,j+,m,n);
             if(i->=&&visited[i-][j]==false)dfs(board,visited,i-,j,m,n);
             if(j->=&&visited[i][j-]==false)dfs(board,visited,i,j-,m,n);
         }
         else
         {
             return;
         }
     }
 };

利用广度优先搜索，先把边界上的O全部放到队列中，然后搜索

 

 class Solution {
 public:
     void solve(vector<vector<char>> &board) {
         int m=board.size();
         if(m==) return;
         int n=board[].size();

         queue<pair<int,int>> q;

         vector<vector<bool>> visited(m,vector<bool>(n,false));
         for(int i=;i<m;i++)
         {
             if(board[i][]=='O') q.push(pair<int,int>(i,));
             if(board[i][n-]=='O')  q.push(pair<int,int>(i,n-));
         }

         for(int j=;j<n;j++)
         {
             if(board[][j]=='O')  q.push(pair<int,int>(,j));
             if(board[m-][j]=='O')  q.push(pair<int,int>(m-,j));
         }

         bfs(q,board,visited,m,n);

         for(int i=;i<m;i++)
         {
             for(int j=;j<n;j++)
             {
                 if(!visited[i][j]&&board[i][j]=='O')  board[i][j]='X';
             }
         }
     }

     void bfs(queue<pair<int,int>> &q,vector<vector<char>> &board,vector<vector<bool>> &visited,int &m,int &n)
     {
         while(!q.empty())
         {
             int ii=q.front().first;
             int jj=q.front().second;
             visited[ii][jj]=true;

             q.pop();

             if(ii+<m&&!visited[ii+][jj]&&board[ii+][jj]=='O') q.push(pair<int,int>(ii+,jj));
             if(ii->=&&!visited[ii-][jj]&&board[ii-][jj]=='O') q.push(pair<int,int>(ii-,jj));
             if(jj+<n&&!visited[ii][jj+]&&board[ii][jj+]=='O') q.push(pair<int,int>(ii,jj+));
             if(jj->=&&!visited[ii][jj-]&&board[ii][jj-]=='O') q.push(pair<int,int>(ii,jj-));
         }
     }
 };