Leetcode | Surrounded Regions

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

 这道题一开始的思路是对的，就是先从边界dfs下去，这条路径上的O在最终都会保留，所以需要特殊标记一下，设为"Z“，”走“哈哈

出现在中间的O只要不能从边界到达的，都应该被改成X。

但是中间出现了一点小问题。一开始用递归总是出现runtime error。害我以为是访问越界了，看了下discussion才知道是stack overflow，正常。于是改用stack实现dfs就可以了。

经验总结：

runtime error 有可能是stack overflow 或者越界。

TLE有可能是出现了死循环。

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

    
    void dfs(vector<vector<char>> &board, int m, int n, int row, int col) {
        stack<int> q;
        q.push(row * n + col);
        
        while (!q.empty()) {
            int pos = q.top();
            q.pop();
            int r = pos / n;
            int c = pos % n;
            board[r][c] = 'Z';
            if (r > 0 && board[r - 1][c] == 'O') q.push((r - 1) * n + c);
            if (r < m - 1 && board[r + 1][c] == 'O') q.push((r + 1) * n + c);
            if (c > 0 && board[r][c - 1] == 'O') q.push(r * n + c - 1);
            if (c < n - 1 && board[r][c + 1] == 'O') q.push(r * n + c + 1);
        }
    }
};

 dfs递归就经常会有栈溢出的情况，所以涉及到遍历，能用bfs就用bfs。

涉及到bfs，就要考虑到是否会有重复添加到队列的情况。

class Solution {
public:
    void solve(vector<vector<char>> &board) {
        int m = board.size();
        if (m <= 1) return;
        int n = board[0].size();
        if (n <= 1) return;
        
        int x[] = {0, 0, 1, -1};
        int y[] = {-1, 1, 0, 0};
        for (int i = 0; i < n; ++i) {
            if (board[0][i] == 'O') bfs(board, x, y, 0, i);
            if (board[m - 1][i] == 'O') bfs(board, x, y, m - 1, i);
        }
        
        for (int i = 0; i < m; ++i) {
            if (board[i][0] == 'O') bfs(board, x, y, i, 0);
            if (board[i][n - 1] == 'O') bfs(board, x, y, 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';
            }
        }
    }
    
    void bfs(vector<vector<char>> &board, int x[], int y[], int row, int col) {
        queue<pair<int, int> > q;
        q.push(pair<int, int>(row, col));
        board[row][col] = '$';
        int m = board.size();
        if (m <= 1) return;
        int n = board[0].size(), newRow, newCol;
        while (!q.empty()) {
            auto loc = q.front(); q.pop();
            
            for (int i = 0; i < 4; ++i) {
                newRow = loc.first + y[i]; 
                newCol = loc.second + x[i];
                if (newRow >= 0 && newRow < m && newCol >= 0 && newCol < n && board[newRow][newCol] == 'O') {
                    board[newRow][newCol] = '$';
                    q.push(pair<int, int>(newRow, newCol));
                }
            }
        }
    }
};