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

» Solve this problem

从四个边界的'O'出发，它们所能到达的'O'就是没有被包围的'O'。

所以，该题可以用BFS遍历或者DFS遍历。

Java代码提交时，大数据偶尔会不通过。

public class Solution {
    private int m, n;
    private char[][] board;
    private Queue<Integer> queue = new LinkedList<Integer>();

    public void add(int x, int y) {
        if (x >= 0 && x < m && y >= 0 && y < n && board[x][y] == 'O') {
            board[x][y] = 'Z';
            queue.offer(x * n + y);
        }
    }
    
    public void traversal(int x, int y) {
        add(x, y);
        while (!queue.isEmpty()) {
            int p = queue.poll();
            int px = p / n;
            int py = p % n;
            add(px - 1, py);
            add(px + 1, py);
            add(px, py - 1);
            add(px, py + 1);
        }
    }

    public void solve(char[][] board) {
        // Start typing your Java solution below
        // DO NOT write main() function
        if (board == null || board.length == 0 || board[0].length == 0) {
            return;
        }
        this.board = board;
        m = board.length;
        n = board[0].length;        
        for (int i = 0; i < n; i++) {
            traversal(0, i);
            traversal(m - 1, i);            
        }
        for (int i = 0; i < m; i++) {
            traversal(i, 0);
            traversal(i, n - 1);
        }
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                board[i][j] = board[i][j] == 'Z' ? 'O' : 'X';
            }
        }
    }
}

C++代码，完全没有问题。

class Solution {
public:
    queue<int> q;
    int m, n;
    
    void add(int x, int y, vector<vector<char>> &board) {
        if (x >= 0 && x < m && y >= 0 && y < n && board[x][y] == 'O') {
            board[x][y] = 'Z';
            q.push(x * n + y);
        }    
    }
    
    void traversal(int x, int y, vector<vector<char>> &board) {
        add(x, y, board);
        while (!q.empty()) {
            int p = q.front();
            q.pop();            
            int px = p / n, py = p % n;
            add(px - 1, py, board);
            add(px + 1, py, board);
            add(px, py - 1, board);
            add(px, py + 1, board);
        }
    }
    
    void solve(vector<vector<char>> &board) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if (board.empty() || board.size() == 0 || board[0].size() == 0) {
            return;
        }
        m = board.size(), n = board[0].size();
        for (int i = 0; i < n; i++) {
            traversal(0, i, board);
            traversal(m - 1, i, board);
        }
        for (int i = 0; i < m; i++) {
            traversal(i, 0, board);
            traversal(i, n - 1, board);
        }
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                board[i][j] = board[i][j] == 'Z' ? 'O' : 'X';
            }
        }
    }
};

C++的DFS

class Solution {
public:  
    int m, n;
    
    void traversal(int x, int y, vector<vector<char>> &board) {
        if (x >= 0 && x < m && y >= 0 && y < n && board[x][y] == 'O') {
            board[x][y] = 'Z';
            traversal(x - 1, y, board);
            traversal(x + 1, y, board);
            traversal(x, y - 1, board);
            traversal(x, y + 1, board);
        }    
    }
    
    void solve(vector<vector<char>> &board) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if (board.empty() || board.size() == 0 || board[0].size() == 0) {
            return;
        }
        m = board.size(), n = board[0].size();
        for (int i = 0; i < n; i++) {
            traversal(0, i, board);
            traversal(m - 1, i, board);
        }
        for (int i = 0; i < m; i++) {
            traversal(i, 0, board);
            traversal(i, n - 1, board);
        }
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                board[i][j] = board[i][j] == 'Z' ? 'O' : 'X';
            }
        }
    }
};