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

Show Tags

Have you met this question in a real interview?

首先想到的是DFS解法，时间问题没过：

DFS

int m;
int n;
vector<vector<char>> theboard;
bool check(int x,int y){
    if(x<0||y<0||x>m-1||y>n-1)
        return false;
    return true;
}
void dfs(int x, int y){
    if(!check(x,y))
        return;
    if(theboard[x][y]!='O')
        return;
    theboard[x][y]='.';
    dfs(x-1,y);
    dfs(x+1,y);
    dfs(x,y-1);
    dfs(x,y+1);
}
void solve(vector<vector<char>> &board) {
    m=board.size();
    if(m==0)
        return;
    n=board[0].size();
    theboard=board;
    for(int i=0;i<m;i++){
        for(int j=0;j<n;j++){
            if(i==0||j==0||i==m-1||j==n-1||board[i][j]=='O'){
                dfs(i,j);
            }
        }
    }
    for(int i=0;i<m;i++){
        for(int j=0;j<n;j++){
            if(board[i][j]=='O')
                board[i][j]='X';
            if(board[i][j]=='.')
                board[i][j]='O';
        }
    }
}

然后只好给出BFS解法，过了

queue<int> q;  
    int m, n;  
      
    void add(int x, int y, vector<vector<char>> &board) {  
        if (x >= 0 && x < m && y >= 0 && y < n && board[x][y] == 'O') {  
            board[x][y] = 'Z';  
            q.push(x * n + y);  
        }      
    }  
      
    void traversal(int x, int y, vector<vector<char>> &board) {  
        add(x, y, board);  
        while (!q.empty()) {  
            int p = q.front();  
            q.pop();              
            int px = p / n, py = p % n;  
            add(px - 1, py, board);  
            add(px + 1, py, board);  
            add(px, py - 1, board);  
            add(px, py + 1, board);  
        }  
    }  
      
    void solve(vector<vector<char>> &board) {  
        if (board.empty() || board.size() == 0 || board[0].size() == 0) {  
            return;  
        }  
        m = board.size(), n = board[0].size();  
        for (int i = 0; i < n; i++) {  
            traversal(0, i, board);  
            traversal(m - 1, i, board);  
        }  
        for (int i = 0; i < m; i++) {  
            traversal(i, 0, board);  
            traversal(i, n - 1, board);  
        }  
        for (int i = 0; i < m; i++) {  
            for (int j = 0; j < n; j++) {  
                board[i][j] = board[i][j] == 'Z' ? 'O' : 'X';  
            }  
        }  
    }