【Surrounded Regions】cpp

题目：

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

代码：

class Solution {
public:
    void solve(vector<vector<char>>& board) {
            const int ROW = board.size();
            if ( ROW< ) return;
            const int COL = board[].size();
            // first row
            for ( int i = ; i < COL; ++i )
            {if ( board[][i]=='O') { board[][i] = 'M'; Solution::bfs(board, , i, ROW, COL); }}
            // last row
            for ( int i = ; i < COL; ++i )
            {if ( board[ROW-][i]=='O' ) { board[ROW-][i] = 'M'; Solution::bfs(board, ROW-, i, ROW, COL); }}
            // first col
            for ( int i = ; i < ROW; ++i )
            {if ( board[i][]=='O' ) { board[i][] = 'M'; Solution::bfs(board, i, , ROW, COL); }}
            // last col
            for ( int i = ; i < ROW; ++i )
            {if ( board[i][COL-]=='O' ) { board[i][COL-]='M'; Solution::bfs(board, i, COL-, ROW, COL); }}
            // flipping surrounded regions
            for ( int i = ; i < ROW; ++i ){
                for ( int j = ; j < COL; ++j ){
                    if ( board[i][j]=='O' ) { board[i][j]='X'; continue; }
                    if ( board[i][j]=='M' ) { board[i][j]='O'; continue; }
                }
            }
    }
        static void bfs(vector<vector<char> >& board, int row, int col, int ROW, int COL )
        {
            queue<pair<int, int> > que;
            que.push(make_pair(row, col));
            while ( !que.empty() ){
                int r = que.front().first, c = que.front().second;
                que.pop();
                // up left down right
                if ( r-> && board[r-][c]=='O' ) { board[r-][c]='M'; que.push(make_pair(r-, c)); }
                if ( c-> && board[r][c-]=='O') { board[r][c-]='M'; que.push(make_pair(r, c-)); }
                if ( r+<ROW- && board[r+][c]=='O' ) { board[r+][c]='M'; que.push(make_pair(r+, c)); }
                if ( c+<COL- && board[r][c+]=='O' ) { board[r][c+]='M'; que.push(make_pair(r, c+)); }
            }
        }
};

tips：

参考的BFS的思路（http://yucoding.blogspot.sg/2013/08/leetcode-question-131-surrounded-regions.html）

先说大体思路

这个思路正好与常规的思路逆过来：

1. 常规的思路是从wall里面挨个BFS遍历，如果从一个'O'出发的所有点都满足封住了，则这BFS走过的点都被封住了，最后赋值为'X'（这样会超时）

2. 而这道题的思路比较好的是逆过来，从边界的'O'出发BFS（因为只要跟边界的'O'连上了，就必然封不住了；而没有与边界的'O'边界连上的'O'自然被封住了）

再说实现细节：

1. 为了不使用额外空间，对于由边界'O'经BFS得到的'O'都置为'M'（M有两个意思：一是访问过了，不用再访问了；二是这个点再最后要恢复为'O'）

2. BFS的时候，终止条件第一次直接写的是que.empty()，一直不对；后来改成了!que.empty()才对，这个低级错误不要再犯。

=========================================

第二次过这道题，有个细节没有注意：

如果发现一个点四周的点是要保留的‘O’时，一定要马上将其设置为‘M’，然后再进行BFS；如果不马上设置为‘M'，那么在BFS的过程中，可能会重复过这个点。

class Solution {
public:
        void solve(vector<vector<char> >& board)
        {
            if ( board.size()< ) return;
            const int m = board.size();
            const int n = board[].size();
            // search from first row
            for ( int i=; i<n; ++i )
            {
                if ( board[][i]=='O' ) Solution::bfs(board, , i, m, n);
            }
            // search from last row
            for ( int i=; i<n; ++i )
            {
                if ( board[m-][i]=='O' ) Solution::bfs(board, m-, i, m, n);
            }
            // search from first column
            for ( int i=; i<m; ++i )
            {
                if ( board[i][]=='O' ) Solution::bfs(board, i, , m, n);
            }
            // search from last column
            for ( int i=; i<m; ++i )
            {
                if ( board[i][n-]=='O' ) Solution::bfs(board, i, n-, m, n);
            }
            // trans 'O' to 'X' & trans 'M' to 'O'
            for ( int i=; i<m; ++i )
            {
                for ( int j=; j<n; ++j )
                {
                    if ( board[i][j]=='O' )
                    {
                        board[i][j]='X';
                        continue;
                    }
                    if ( board[i][j]=='M' )
                    {
                        board[i][j]='O';
                    }
                }
            }
        }
        static void bfs(vector<vector<char> >& board, int r, int c, int ROW, int COL)
        {
            board[r][c] = 'M';
            queue<pair<int, int> > curr;
            queue<pair<int, int> > next;
            curr.push(make_pair(r, c));
            while ( !curr.empty() )
            {
                while ( !curr.empty() )
                {
                    int i = curr.front().first;
                    int j = curr.front().second;
                    curr.pop();
                    // up
                    if ( i->= && board[i-][j]=='O' )
                    {
                        board[i-][j] = 'M';
                        next.push(make_pair(i-, j));
                    }
                    // down
                    if ( i+<ROW && board[i+][j]=='O' )
                    {
                        board[i+][j] = 'M';
                        next.push(make_pair(i+, j));
                    }
                    // left
                    if ( j->= && board[i][j-]=='O' )
                    {
                        board[i][j-] = 'M';
                        next.push(make_pair(i, j-));
                    }
                    // right
                    if ( j+<COL && board[i][j+]=='O' )
                    {
                        board[i][j+] = 'M';
                        next.push(make_pair(i, j+));
                    }
                }
                swap(next, curr);
            }
        }
};