[LintCode] 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.

Have you met this question in a real interview? 

Yes

Example

X X X X
X O O X
X X O X
X O X X

After capture all regions surrounded by 'X', the board should be:

X X X X
X X X X
X X X X
X O X X

 

Solution 1. BFS, O(n * m) runtime, O(n * m) space

For each unvisited cell of 'O', do a bfs and add all connected && unvisited cells of 'O' to a list. If at any point, we determine that a cell of 'O' is on one of the four edges of the board, 

mark the flag surrounded to false as this whole list of 'O's are not surrounded by 'X'. Otherwise, set it to true.

 

For each list, if the flag surrounded is true, change all the cells in this list to 'X'.

 

Runtime analysis: each cell is visited at most two times, first time for all cells, second time for cells that are 'O' and surrounded by 'X', so O(n * m).

 

This solution is pretty straightforward, but it must use extra O(n * m) memory to keep track if a cell has been visited and save all connected cells of 'O'.

public class Solution {
    private class Point {
        int x, y;
        Point(int x, int y){
            this.x = x;
            this.y = y;
        }
    }
    public void surroundedRegions(char[][] board) {
        if(board == null || board.length == 0 || board[0].length == 0){
            return;
        }
        int n = board.length, m = board[0].length;
        boolean[][] visited = new boolean[n][m];
        
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                if(visited[i][j] == false && board[i][j] == 'O'){
                    ArrayList<Point> points = new ArrayList<Point>();  
                    if(bfsHelper(board, i, j, points, visited)){
                        for(int k = 0; k < points.size(); k++){
                            board[points.get(k).x][points.get(k).y] = 'X';
                        }
                    }
                }    
            }
        }
    }
    private boolean bfsHelper(char[][] board, int i, int j, 
                            ArrayList<Point> points,
                            boolean[][] visited){
        boolean surrounded = true;
        Queue<Point> queue = new LinkedList<Point>();
        Point newP = new Point(i, j);
        queue.add(newP);
        visited[i][j] = true;
        points.add(newP);
        int[] deltaX = {-1, 0, 1, 0};
        int[] deltaY = {0, 1, 0, -1};
        
        while(queue.isEmpty() == false){
            Point curr = queue.poll();
            for(int dir = 0; dir < 4; dir++){
                int x = curr.x + deltaX[dir];
                int y = curr.y + deltaY[dir];
                //if a 'O' has out of bound neighbors, it means this 'O' is not 
                //surrounded.
                if(isValidPoint(board, x, y) == false){
                    surrounded = false;
                }
                else if(board[x][y] == 'O' && visited[x][y] == false){
                    newP = new Point(x, y);
                    queue.add(newP);
                    visited[x][y] = true;
                    points.add(newP);
                }
            }
        }
        return surrounded;
    }
    private boolean isValidPoint(char[][] board, int i, int j){
        return !(i < 0 || i >= board.length || j < 0 || j >= board[0].length);
    }
}

Solution 2. BFS, O(n * m) runtime, with a better space complexity on average, still O(n * m) space for the queue used in bfs in the worst case

If a cell is 'O' and not surrounded by 'X', it means this cell must be connected via a bunch of other 'O's to a 'O' that is on the edge of the board.

Solution 1 starts from inside and try to hit the edge to determine if a group of connected Os are surrounded by X or not. 

Instead, we can try to solve this problem in a reversed fashion. If we starts at Os at the edges and do bfs on connected Os toward the inside of the board, 

we can find all connected Os that are NOT surrounded by X. The benefit of this reverse is that we can change the Os to Ws along the way to mark that 

these cells are not surrounded by X. After we are done with all bfs, we do a final iteration of the board and change all Ws to Os and all non Ws to Xs. 

This is correct since Os that are surround by X is not reachable from the edgy Os and will stay as Os after the bfs. Marking Ws on the fly also save 

us from using an extra 2D array to track if a cell has been visited. A visited O will be changed to W and it will not be visited again.

public class Solution {
    public void surroundedRegions(char[][] board) {
        if(board == null || board.length == 0 || board[0].length == 0) {
            return;
        }
        int n = board.length;
        int m = board[0].length;
        for(int i = 0; i < n; i++) {
            bfsFromEdgeOfBoard(board, i, 0);
            bfsFromEdgeOfBoard(board, i, m - 1);
        }
        for(int j = 0; j < m; j++) {
            bfsFromEdgeOfBoard(board, 0, j);
            bfsFromEdgeOfBoard(board, n - 1, j);
        }
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < m; j++) {
                if(board[i][j] == 'W') {
                    board[i][j] = 'O';
                }
                else {
                    board[i][j] = 'X';
                }
            }
        }
    }
    private void bfsFromEdgeOfBoard(char[][] board, int row, int col) {
        if(board[row][col] != 'O') {
            return;
        }
        int[] deltaX = {-1, 0, 1, 0};
        int[] deltaY = {0, 1, 0, -1};
        Queue<Integer> qx = new LinkedList<Integer>();
        Queue<Integer> qy = new LinkedList<Integer>();
        qx.add(row);
        qy.add(col);
        board[row][col] = 'W';
        
        while(!qx.isEmpty()) {
            int cx = qx.poll();
            int cy = qy.poll();
            for(int dir = 0; dir < 4; dir++) {
                int nx = cx + deltaX[dir];
                int ny = cy + deltaY[dir];
                if(isInBound(board, nx, ny) && board[nx][ny] == 'O') {
                    board[nx][ny] = 'W';
                    qx.add(nx);
                    qy.add(ny);
                }
            }
        }
    }
    private boolean isInBound(char[][] board, int row, int col) {
        return row >= 0 && row < board.length && col >= 0 && col < board[0].length; 
    }
}

Solution 3. Union Find, O(n * m) runntime, O(n * m) space 

1. write a UnionFind class that supports finding root and connect roots at O(1) time.

2. for each unvisited O, connect its neighboring unvisited Os. Make sure when connecting roots, always make edge cells of O as the new root if possible. 

3. after iterating the whole board at step 2, we get a balanced union find data structure that contains all cells. The O cells' roots are also updated to reflect if 

they belong in the same union. Check each O cell to see if it has a edge cell O as its root, if it does, do nothing; if it does not, change it from O to X.

 

public class Solution {
    private class UnionFind {
        private int[] father = null;
        private int row = 0;
        private int col = 0;
        public UnionFind(int n, int m){
            row = n;
            col = m;
            father = new int[n * m];
            for(int i = 0; i < n * m; i++){
                father[i] = i;
            }
        }
        public int find(int x){
            if(father[x] == x){
                return x;
            }
            return father[x] = find(father[x]);
        }
        public void connect(int a, int b){
            int root_a = find(a);
            int root_b = find(b);
            if(root_a != root_b){
                if(ifRootOnMatrixOutEdge(row, col, root_a) == true){
                    father[root_b] = root_a;
                }
                else{
                    father[root_a] = root_b;
                }
            }
        }
    }
    public void surroundedRegions(char[][] board) {
        if(board == null || board.length == 0 || board[0].length == 0){
            return;
        }
        int n = board.length;
        int m = board[0].length;
        UnionFind uf = new UnionFind(n, m);
        boolean[][] visited = new boolean[n][m];
        int[] deltaX = {-1, 0, 1, 0};
        int[] deltaY = {0, 1, 0, -1};
        for(int i = 0; i < n; i ++){
            for(int j = 0; j < m; j++){
                if(board[i][j] == 'O' && visited[i][j] == false){
                    for(int dir = 0; dir < 4; dir++){
                        int x = i + deltaX[dir];
                        int y = j + deltaY[dir];
                        if(isValidPoint(board, x, y) && board[x][y] == 'O' &&
                           visited[x][y] == false){
                            uf.connect(i * m + j, x * m + y);
                        }
                    } 
                    visited[i][j] = true;
                }

            }
        }
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                if(board[i][j] == 'O' && !ifRootOnMatrixOutEdge(n, m, uf.find(i * m + j))){
                    board[i][j] = 'X';
                }    
            }
        }
    }
    private boolean ifRootOnMatrixOutEdge(int rowNum, int colNum, int rootIdx){
        return (rootIdx >= 0 && rootIdx <= colNum - 1
                || rootIdx >= (rowNum - 1) * colNum && rootIdx <= rowNum * colNum - 1
                || rootIdx % colNum == 0
                || rootIdx % colNum == colNum - 1);
    }
    private boolean isValidPoint(char[][] board, int i, int j){
        return !(i < 0 || i >= board.length || j < 0 || j >= board[0].length);
    }
}

 

Related Problems

Nearest Exit

Connecting Graph

Number of Islands II

Number of Islands