Surrounded Regions

Q:

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

A:
使用BFS，每次都从为‘O’的点出发，保存所有能连通的‘O’，并判断这些连通的‘O’是否被‘X’包围，如果没有被包围，然后将其改为临时点‘#’，如果被包围，将其改为‘X’用以标记其已经被访问。BFS过后再将其重置为‘O’即可。这样用以保存节点是否被访问的数据结构会小一点。

第二种方法使用一个全局的hash_table保存当前节点是否被访问，但是不需要将‘O’重置为临时字符。可能会稍微快一些。但是需要额外的m*n的空间。

class Solution {
public:
    void solve(vector<vector<char>> &board) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        r_ = board.size();
        if (r_ == 0) return;
        c_ = board[0].size();
        if (c_ == 0) return;
        for (int i = 0; i < r_; ++i) {
            for (int j = 0; j < c_; ++j) {
                Bfs(board, i, j);
            }
        }
        for (int i = 0; i < r_; ++i) {
            for (int j = 0; j < c_; ++j) {
                if (board[i][j] == '#') {
                    board[i][j] = 'O';
                }
            }
        }
    }
    
private:
    
    void Bfs(vector<vector<char>> &board, int x, int y) {
        if (board[x][y] != 'O') return;
        visit_.clear();
        bool surrounded = true;
        int cur_pos = x*c_ + y;
        visit_.insert(cur_pos);
        q_.push(cur_pos);
        while (!q_.empty()) {
            cur_pos = q_.front();
            q_.pop();
            if (cur_pos/c_ == 0 || cur_pos/c_ == r_ - 1 ||
                cur_pos%c_ == 0 || cur_pos%c_ == c_ - 1) {
                surrounded = false;
            }
            for (int i = 0; i < 4; ++i) {
                int neighour_x = cur_pos/c_ + surround_x_[i];
                int neighour_y = cur_pos%c_ + surround_y_[i];
                if (neighour_x < 0 || neighour_x >= r_ ||
                    neighour_y < 0 || neighour_y >= c_ ||
                    visit_.find(neighour_x*r_ + neighour_y) != visit_.end() ||
                    board[neighour_x][neighour_y] != 'O') {
                    continue;
                }

                visit_.insert(neighour_x*r_ + neighour_y);
                q_.push(neighour_x*r_ + neighour_y);
            }
        }
        for (set<int>::iterator iter = visit_.begin(); iter != visit_.end(); ++iter) {
            board[*iter/c_][*iter%c_] = surrounded ? 'X' : '#';
        }
        return;
    }
    
private:
    set<int> visit_;
    queue<int> q_;
    int r_;
    int c_;
    static const int surround_x_[4];
    static const int surround_y_[4];
};
const int Solution::surround_x_[4] = {-1, 0, 1, 0};
const int Solution::surround_y_[4] = {0, 1, 0, -1};

Solution2:
真操蛋，我用leetcode提供的测试例用自己的main测试正确，到了leetcode上测试的结果就不一样。烦躁了。代码应该是没有问题的。

class Solution {
public:
    void solve(vector<vector<char> > &board) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        r_ = board.size();
        if (r_ == 0) return;
        c_ = board[0].size();
        if (c_ == 0) return;
        visit_.resize(r_*c_, false);
        for (int i = 0; i < r_; ++i) {
            for (int j = 0; j < c_; ++j) {
                Bfs(board, i, j);
            }
        }
    }
    
private:   
    void Bfs(vector<vector<char> > &board, int x, int y) {
        if (board[x][y] != 'O' || visit_[x*c_ + y]) return;
        bool surrounded = true;
        int cur_pos = x*c_ + y;
        handle_poses_.clear();
        visit_[cur_pos] = true;
        handle_poses_.push_back(cur_pos);
        int idx = 0;
        while (idx < handle_poses_.size()) {
            cur_pos = handle_poses_[idx++];
            if (cur_pos/c_ == 0 || cur_pos/c_ == r_ - 1 ||
                cur_pos%c_ == 0 || cur_pos%c_ == c_ - 1) {
                surrounded = false;
            }
            for (int i = 0; i < 4; ++i) {
                int neighour_x = cur_pos/c_ + surround_x_[i];
                int neighour_y = cur_pos%c_ + surround_y_[i];
                if (neighour_x < 0 || neighour_x >= r_ ||
                    neighour_y < 0 || neighour_y >= c_ ||
                    visit_[neighour_x*r_ + neighour_y] ||
                    board[neighour_x][neighour_y] != 'O') {
                    continue;
                }

                visit_[neighour_x*r_ + neighour_y] = true;
                handle_poses_.push_back(neighour_x*r_ + neighour_y);
            }
        }
        if (surrounded == false) return;
        for (int i = 0; i < handle_poses_.size(); ++i) {
            board[handle_poses_[i]/c_][handle_poses_[i]%c_] = 'X';
        }
        return;
    }
    
private:
    vector<bool> visit_;
    vector<int> handle_poses_;
    int r_;
    int c_;
    static const int surround_x_[4];
    static const int surround_y_[4];
};
const int Solution::surround_x_[4] = {-1, 0, 1, 0};
const int Solution::surround_y_[4] = {0, 1, 0, -1};