130. Surrounded Regions

这道题可以帮助大家学习一下深搜和广搜，连通性问题，而且是四联通，具体的思路简单，代码比较长，没啥太突出的技巧性。

DFS：

class Solution {
public:
    void solve(vector<vector<char>>& board) {
        if (board.empty() || board.size()<2 || board[0].size()<2) {
            return ;
        }

        for (int i=0; i<board[0].size(); ++i) {
            if (board[0][i] == 'O') {
                mark (0, i, board);
            }
            
            if (board[board.size()-1][i] == 'O') {
                mark (board.size()-1, i, board);
            }
        }
        
        for (int i=1; i<board.size()-1; ++i) {
            if (board[i][0] == 'O') {
                mark (i, 0, board);
            }
            
            if (board[i][board[0].size()-1] == 'O') {
                mark (i, board[0].size()-1, board);
            }
        }
        
        
        
        for (int i=0; i<board.size(); ++i) {
            for (int j=0; j<board[0].size(); ++j) {
                if (board[i][j] == 'O') {
                    board[i][j] = 'X';
                } else if (board[i][j] == 'E'){
                    board[i][j] = 'O';
                }
            }
        }
    }
    
    void mark (int row, int col, vector<vector<char> >& board) {
        if (row<0 || row>board.size()-1 || col<0 || col>board[0].size()-1) {
            return ;
        }
        
        if (board[row][col] == 'O') {
            board[row][col] = 'E';
        } else {
            return ;
        }
        
        mark (row-1, col, board);
        mark (row+1, col, board);
        mark (row, col-1, board);
        mark (row, col+1, board);
    }
};

BFS：

class Solution {
public:
    void solve(vector<vector<char>>& board) {
        if (board.empty() || board.size()<2 || board[0].size()<2) {
            return ;
        }
        
        queue<pair<int, int> > alivequ;
        for (int i=0; i<board[0].size(); ++i) {
            if (board[0][i] == 'O') {
                board[0][i] = 'E';
                alivequ.push(make_pair(0, i));
            }
            
            if (board[board.size()-1][i] == 'O') {
                board[board.size()-1][i] = 'E';
                alivequ.push(make_pair(board.size()-1, i));
            }
        }
        
        for (int i=1; i<board.size()-1; ++i) {
            if (board[i][0] == 'O') {
                board[i][0] = 'E';
                alivequ.push(make_pair(i, 0));
            }
            
            if (board[i][board[0].size()-1] == 'O') {
                board[i][board[0].size()-1] = 'E';
                alivequ.push(make_pair(i, board.size()-1));
            }
        }
        
        
        
        
        while (!alivequ.empty()) {
            auto ans = alivequ.front();
            alivequ.pop();
            int row = ans.first;
            int col = ans.second;
            
            if (col-1 >=0 ) {
                if (board[row][col-1] == 'O') {
                    board[row][col-1] = 'E';
                    alivequ.push(make_pair(row, col-1));
                }
            }
            
            if(col+1<board[0].size()){   
                if (board[row][col+1] == 'O') {
                    board[row][col+1] = 'E';
                    alivequ.push(make_pair(row, col+1));
                }
            }
            
            if (row-1 >= 0) {
                if (board[row-1][col] == 'O') {
                    board[row-1][col] = 'E';
                    alivequ.push(make_pair(row-1, col));
                }
            }
            
            if (row+1<board.size()){
                if (board[row+1][col] == 'O') {
                    board[row+1][col] = 'E';
                    alivequ.push(make_pair(row+1, col));
                }
            }
        }
        

        
        
        for (int i=0; i<board.size(); ++i) {
            for (int j=0; j<board[0].size(); ++j) {
                if (board[i][j] == 'O') {
                    board[i][j] = 'X';
                } else if (board[i][j] == 'E'){
                    board[i][j] = 'O';
                }
            }
        }
    }
};

比较奇怪的是，dfs要比bfs的效率高点，可能是队列占用时间的原因。