130. Surrounded Regions

Given a 2D board containing ‘X’ and ‘O’ (the letter O), capture all regions surrounded by ‘X’.

A region is captured by flipping all 'O’s into 'X’s in that surrounded region.

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

Explanation:

Surrounded regions shouldn’t be on the border, which means that any ‘O’ on the border of the board are not flipped to ‘X’. Any ‘O’ that is not on the border and it is not connected to an ‘O’ on the border will be flipped to ‘X’. Two cells are connected if they are adjacent cells connected horizontally or vertically.

https://www.cnblogs.com/higerzhang/p/4149040.html

思路：
http://www.cnblogs.com/grandyang/p/4555831.html
Explanation当中透露了思路。我们的目标是找到所有与某一个在边界的’O’相连的‘O’，可以用dfs或者bfs来做。dfs容易造成栈溢出，需要限定搜索的边界来避免。

方法1: DFS

class Solution {
public:
    void solve(vector<vector<char>>& board) {
        if (board.size() == 0 || board[0].size() == 0) return;
        int m = board.size();
        int n = board[0].size();
        for (int i = 0; i < m; i++){
            for (int j = 0; j < n; j++)
                if ((i == 0 || i == board.size() - 1||j ==0 || j == board[0].size() - 1) &&  board[i][j] == 'O')
                    dfs(board, 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';
            }
        }
        return;
        
    }
    
    void dfs(vector<vector<char>> & board, int i, int j){
        if (board[i][j] == 'O'){
            int m = board.size();
            int n = board[0].size();
            board[i][j] = '$';
        
        if (i > 0 && board[i - 1][j] == 'O'){
            dfs(board, i - 1, j);
        }
        
        if (i < m - 1 && board[i + 1][j] == 'O'){
            dfs(board, i + 1, j);
        }
        
        if (j > 0 && board[i][j - 1] == 'O'){
            dfs(board, i, j - 1);
        }
        
        if (j < n - 1 && board[i][j + 1] == 'O'){
            dfs(board, i, j + 1);
        }
        return;
        }
    }
};

方法2: BFS

我们也可以使用迭代的解法，但是整体的思路还是一样的，我们在找到边界上的O后，然后利用队列queue进行BFS查找和其相连的所有O，然后都标记上美元号。最后的处理还是先把所有的O变成X，然后再把美元号变回O即可，参见代码如下：

class Solution {
public:
    void solve(vector<vector<char>>& board) {
        if (board.size() == 0 || board[0].size() == 0) return;
        int m = board.size();
        int n = board[0].size();
        
        queue<pair<int, int>> myQueue;
        
        for (int i = 0; i < m; i++){
            for (int j = 0; j < n; j++)
                if ((i == 0 || i == board.size() - 1||j ==0 || j == board[0].size() - 1) &&  board[i][j] == 'O'){
                    myQueue.push(make_pair(i, j));
                }          
        }
        
        // call bfs
        bfs(board, myQueue);
        
        // final flip
        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';
            }
        }
        return;
    }
    
    void bfs(vector<vector<char>> & board, queue<pair<int, int>> & q){
        int m = board.size();
        int n = board[0].size();
        
        while (!q.empty()){
            int i = q.front().first;
            int j = q.front().second;
            q.pop();
           
            board[i][j] = '$';
            if (i > 0 && board[i - 1][j] == 'O'){
               q.push(make_pair(i - 1, j));
             }
        
        if (i < m - 1 && board[i + 1][j] == 'O'){
           q.push(make_pair(i + 1, j));
        }
        
        if (j > 0 && board[i][j - 1] == 'O'){
            q.push(make_pair(i, j - 1));
        }
        
        if (j < n - 1 && board[i][j + 1] == 'O'){
           q.push(make_pair(i, j + 1));
        }
        }
        return;
    }
};