LeetCode-Surrounded Regions

哎，做得比较郁闷的一道题，如果面试做这一题的话，肯定就跪了，一开始的时候思路就错了，只想着怎样把“O"变成"X"，解的过程是遇到了"O"了再去判断，以dfs的方式遍历它四周的点，判断是否被"X"包围，如果被包围的话则改成"O"。只能过小数据，

大数据会在一个超长的输入那里出现Runtime Error。

后来到网上看了一下，发现正确的思路应该是用dfs或者bfs从外面一圈判断是否可连接到外面的”O"，因为如果最外面一圈如果都是"X"的话，那么肯定是被包围的，所有的”O“都要被改成”X"。

DFS的代码很好写，不过奇怪的是我写完之后过不了大数据，可是看了一位同学的代码（http://blog.csdn.net/tuantuanls/article/details/8746458），和我写的基本一样，可是却可以过，而且她的代码中没有判断r < 0 || c < 0，竟然还能通过，感觉很诡异。后来我把bfs中的局部变量m = board.size(); n = board[0].size()；去掉之后就能通过了！⊙﹏⊙b汗，这也行。。。

class Solution {
public:
    void dfs(vector<vector<char> > &board, int r, int c) {
        //int m = board.size();
        //int n = board[0].size();
        //if (r < 0 || c < 0 || r >= m || c >= n || board[r][c] != 'O') return;
        if (r < 0 || c < 0 || r >= board.size()  || c >= board[0].size() || board[r][c] != 'O') {
            return;
        }
        board[r][c] = '#';
        dfs(board, r, c + 1);
        dfs(board, r, c - 1);
        dfs(board, r + 1, c);
        dfs(board, r - 1, c);
    }
    void solve(vector<vector<char> > &board) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        int m = board.size();
        if (m == 0) {
            return;
        }
        int n = board[0].size();
        for (int j = 0; j < n; j++) {
            dfs(board, 0, j);
            dfs(board, m - 1, j);
        }
        for (int i = 1; i < m - 1; i++) {
            dfs(board, i, 0);
            dfs(board, i, n - 1);
        }
        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的话可以一次顺利通过，队列我用的是C++ STL中的双端队列deque。

class Solution {
public:
    deque<int> around;
    void change(vector<vector<char> > &board, int r, int c) {
        if (r < 0 || c < 0 || r >= board.size()  || c >= board[0].size() || board[r][c] != 'O') {
            return;
        }
        board[r][c] = '1';
        around.push_back(r * board[0].size() + c);
    }
    void bfs(vector<vector<char> > &board, int r, int c) {
        change(board, r, c);
        while (!around.empty()) {
            int pos = around.front();
            int i = pos / board[0].size();
            int j = pos % board[0].size();
            change(board, i, j + 1);
            change(board, i, j - 1);
            change(board, i - 1, j);
            change(board, i + 1, j);
            around.pop_front();
        }
    }
    void solve(vector<vector<char> > &board) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        int m = board.size();
        if (m == 0) {
            return;
        }
        int n = board[0].size();
        around.clear();
        for (int j = 0; j < n; j++) {
            bfs(board, 0, j);
            bfs(board, m - 1, j);
        }
        for (int i = 1; i < m - 1; i++) {
            bfs(board, i, 0);
            bfs(board, i, n - 1);
        }
        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] == '1') {
                    board[i][j] = 'O';
                }
            }
        }
    }
};