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

难度：92。这个题目用到的方法是图形学中的一个常用方法：Flood fill算法，其实就是从一个点出发对周围区域进行目标颜色的填充。背后的思想就是把一个矩阵看成一个图的结构，每个点看成结点，而边则是他上下左右的相邻点，然后进行一次广度或者深度优先搜索。

这道题首先四个边缘上的‘O’点都不是被surrounded的，这是很直接能看出的，麻烦的是与这些边界上的‘O’点毗邻的其他‘O’点，这些点由于跟边缘上的'O'毗邻，所以也米有被‘X’包裹住。所以我们的想法是：把边界上的‘O’点都找出来，对它们做Flood Fill, 把联通的‘O’区域找出来，把这个区域的点统统由‘O’替换为其他字符比如‘$’。这样没有被替换仍旧为‘O’的那些点，就是被‘X’包裹的。这样整体扫描一次，剩下的所有'O'都应该被替换成'X'，而'$'那些最终应该是还原成'O'。

复杂度分析上，我们先对边缘做Flood fill算法，因为只有是'O'才会进行，而且会被替换成'#'，所以每个结点改变次数不会超过一次，因而是O(m*n)的复杂度，最后一次遍历同样是O(m*n)，所以总的时间复杂度是O(m*n)。

空间上没懂，看了别人的思路。空间上就是递归栈（深度优先搜索）或者是队列（广度优先搜索）的空间，同时存在的空间占用不会超过O(m+n)（以广度优先搜索为例，每次队列中的结点虽然会往四个方向拓展，但是事实上这些结点会有很多重复，假设从中点出发，可以想象最大的扩展不会超过一个菱形，也就是n/2*2+m/2*2=m+n，所以算法的空间复杂度是O(m+n)）

方法选择当然DFS和BFS都可以，DFS如果用递归来实现，像Flood Fill算法里那样，图形或者矩阵一般很大，递归容易导致堆栈溢出。所以即使用DFS，也要用Stack来写。

Approach 1: BFS

public class Solution {
    int[][] dirs = new int[][]{{-1, 0}, {1, 0}, {0, 1}, {0, -1}};
    
    public void solve(char[][] board) {
        if(board == null || board.length == 0 || board[0].length == 0) return;
        for (int j=0; j<board[0].length; j++) {
            if (board[0][j] == 'O') bfs(board, 0, j);
            if (board[board.length-1][j] == 'O') bfs(board, board.length-1, j);
        }
        for (int i=0; i<board.length; i++) {
            if (board[i][0] == 'O') bfs(board, i, 0);
            if (board[i][board[0].length-1] == 'O') bfs(board, i, board[0].length-1);
        }
        for (int i=0; i<board.length; i++) {
            for (int j=0; j<board[0].length; j++) {
                if (board[i][j] == 'X') continue;
                else if (board[i][j] == '$') board[i][j] = 'O';
                else if (board[i][j] == 'O') board[i][j] = 'X';
            }
        }
    }
    
    public void bfs(char[][] board, int i, int j) {
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{i, j});
        board[i][j] = '$';
        while (queue.size() != 0) {
            int[] pair = queue.poll();
            int row = pair[0];
            int col = pair[1];
            
            for (int[] dir : dirs) {
                int x = row + dir[0];
                int y = col + dir[1];
                if (x >= 0 && x < board.length && y >= 0 && y < board[0].length && board[x][y] == 'O') {
                    queue.offer(new int[]{x, y});
                    board[x][y] = '$';
                }
            }
        }
    }
}

1. 注意BFS一般都需要Visited数组，这里访问元素设置为‘$’其实就相当于做了，就不需要额外visited数组了

2. 注意设置一个元素为visited的位置，应该在首次把元素放入queue里面的时候（enqueue时），而不是把元素从queue里poll出来的时候，后者TLE错误(错误原因是：enqueue就一定会dequeue，enqueue了就表示一定会visit，所以一定要在这时设置visited，否则如果enqueue了却不设置为visited，其它相邻的点访问的时候也会把这个已经enqueue的点再次enqueue，就会重复访问)。 如下例子所示：

1----2

|    /

|  /

3

这个graph1，2，3三个点相邻，假设规则是从queue poll出来的时候才设置visited，那么1点visited以后，2，3两个点都enqueue，但并未visited，2点poll的时候，设置2为visited，同时enqueue 3点。这样3点就enqueue了两次！出错了

3. 这道题设置visited数组比较特殊，完了之后不需要再撤销visited，即不需要把变成“$”的元素变回“O”。因为题目要求就是要保留这种变化

 下面是一段用递归写的DFS算法，一旦input很大就stack overflow了

public class Solution {
    public void solve(char[][] board) {
        if(board == null || board.length == 0 || board[0].length == 0) return;
        for (int j=0; j<board[0].length; j++) {
            if (board[0][j] == 'O') dfs(board, 0, j);
            if (board[board.length-1][j] == 'O') dfs(board, board.length-1, j);
        }
        for (int i=0; i<board.length; i++) {
            if (board[i][0] == 'O') dfs(board, i, 0);
            if (board[i][board[0].length-1] == 'O') dfs(board, i, board[0].length-1);
        }
        for (int i=0; i<board.length; i++) {
            for (int j=0; j<board[0].length; j++) {
                if (board[i][j] == '$') board[i][j] = 'O';
                else if (board[i][j] == 'O') board[i][j] = 'X';
            }
        }
    }
    
    public void dfs(char[][] board, int i, int j) {
        if (i<0 || i>=board.length || j<0 || j>=board[0].length || board[i][j] != 'O') return;
        if (board[i][j] == 'O') board[i][j] = '$';
        dfs(board, i-1, j);
        dfs(board, i+1, j);
        dfs(board, i, j-1);
        dfs(board, i, j+1);
    }
}

Union Find: Just know this idea, too complex for this problem

public class Solution {
    int rows, cols;
    
    public void solve(char[][] board) {
        if(board == null || board.length == 0) return;
        
        rows = board.length;
        cols = board[0].length;
        
        // last one is dummy, all outer O are connected to this dummy
        UnionFind uf = new UnionFind(rows * cols + 1);
        int dummyNode = rows * cols;
        
        for(int i = 0; i < rows; i++) {
            for(int j = 0; j < cols; j++) {
                if(board[i][j] == 'O') {
                    if(i == 0 || i == rows-1 || j == 0 || j == cols-1) {
                        uf.union(node(i,j), dummyNode);
                    }
                    else {
                        if(i > 0 && board[i-1][j] == 'O')  uf.union(node(i,j), node(i-1,j));
                        if(i < rows-1 && board[i+1][j] == 'O')  uf.union(node(i,j), node(i+1,j));
                        if(j > 0 && board[i][j-1] == 'O')  uf.union(node(i,j), node(i, j-1));
                        if(j < cols-1 && board[i][j+1] == 'O')  uf.union(node(i,j), node(i, j+1));
                    }
                }
            }
        }
        
        for(int i = 0; i < rows; i++) {
            for(int j = 0; j < cols; j++) {
                if(uf.isConnected(node(i,j), dummyNode)) {
                    board[i][j] = 'O';
                }
                else {
                    board[i][j] = 'X';
                }
            }
        }
    }
    
    int node(int i, int j) {
        return i * cols + j;
    }
}

class UnionFind {
    int [] parents;
    public UnionFind(int totalNodes) {
        parents = new int[totalNodes];
        for(int i = 0; i < totalNodes; i++) {
            parents[i] = i;
        }
    }
    
    void union(int node1, int node2) {
        int root1 = find(node1);
        int root2 = find(node2);
        if(root1 != root2) {
            parents[root2] = root1;
        }
    }
    
    int find(int node) {
        while(parents[node] != node) {
            parents[node] = parents[parents[node]];
            node = parents[node];
        }
        
        return node;
    }
    
    boolean isConnected(int node1, int node2) {
        return find(node1) == find(node2);
    }
}