【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==0) return;
        int n=board[0].size();
       
        vector<vector<bool>> visited(m,vector<bool>(n,false));
        for(int i=0;i<m;i++)
        {
            if(board[i][0]=='O'&&!visited[i][0])
            {
                dfs(board,visited,i,0,m,n);
            }
           
            if(board[i][n-1]=='O'&&!visited[i][n-1])
            {
                dfs(board,visited,i,n-1,m,n);
            }
        }
       
        for(int j=0;j<n;j++)
        {
           
            if(board[0][j]=='O'&&!visited[0][j])
            {
                dfs(board,visited,0,j,m,n);
            }
           
            if(board[m-1][j]=='O'&&!visited[m-1][j])
            {
                dfs(board,visited,m-1,j,m,n);
            }
           
        }
       
       
        for(int i=0;i<m;i++)
        {
            for(int j=0;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+1<m&&visited[i+1][j]==false)dfs(board,visited,i+1,j,m,n);
            if(j+1<n&&visited[i][j+1]==false)dfs(board,visited,i,j+1,m,n);
            if(i-1>=0&&visited[i-1][j]==false)dfs(board,visited,i-1,j,m,n);
            if(j-1>=0&&visited[i][j-1]==false)dfs(board,visited,i,j-1,m,n);
        }
        else
        {
            return;
        }
    }       
};

 

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

 

class Solution {
public:
    void solve(vector<vector<char>> &board) {
        int m=board.size();
        if(m==0) return;
        int n=board[0].size();
       
        queue<pair<int,int>> q;
       
        vector<vector<bool>> visited(m,vector<bool>(n,false));
        for(int i=0;i<m;i++)
        {
            if(board[i][0]=='O') q.push(pair<int,int>(i,0));
            if(board[i][n-1]=='O')  q.push(pair<int,int>(i,n-1));
        }
       
        for(int j=0;j<n;j++)
        {
            if(board[0][j]=='O')  q.push(pair<int,int>(0,j));
            if(board[m-1][j]=='O')  q.push(pair<int,int>(m-1,j));
        }
       
        bfs(q,board,visited,m,n);
       
        for(int i=0;i<m;i++)
        {
            for(int j=0;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+1<m&&!visited[ii+1][jj]&&board[ii+1][jj]=='O') q.push(pair<int,int>(ii+1,jj));
            if(ii-1>=0&&!visited[ii-1][jj]&&board[ii-1][jj]=='O') q.push(pair<int,int>(ii-1,jj));
            if(jj+1<n&&!visited[ii][jj+1]&&board[ii][jj+1]=='O') q.push(pair<int,int>(ii,jj+1));
            if(jj-1>=0&&!visited[ii][jj-1]&&board[ii][jj-1]=='O') q.push(pair<int,int>(ii,jj-1));
        }
    }
};