力扣第130题被围绕的区域

130.被围绕的区域
难度：中等
标签：深度优先，广度优先，并查集

给定一个二维的矩阵，包含 ‘X’ 和 ‘O’（字母 O）。
找到所有被 ‘X’ 围绕的区域，并将这些区域里所有的 ‘O’ 用 ‘X’ 填充。

示例:
X X X X
X O O X
X X O X
X O X X
运行你的函数后，矩阵变为：

X X X X
X X X X
X X X X
X O X X
解释:
被围绕的区间不会存在于边界上，换句话说，任何边界上的 ‘O’ 都不会
被填充为 ‘X’。 任何不在边界上，或不与边界上的 ‘O’ 相连
的 ‘O’ 最终都会被填充为 ‘X’。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。

并查集的思路：
吧所有边界为0的结点与虚拟结点相连通
然后把为0的且相连的结点，连在一个连通分量里面，
最后只用判断，每个结点是否在虚拟结点的连通分量里面，在的话就不用修改，不在的话就修改为X

public void solve(char[][] board) {
    if(board==null||board.length==0||board[0].length==0)
        return;
    int rows = board.length;
    int cols = board[0].length;
    //单独设一个虚拟根结点，所有边界上的O的结点都连在这个结点上
    int last = rows*cols;
    UF uf = new UF(rows * cols + 1);
    for (int i = 0; i < board.length; i++) {
        for (int j = 0; j < board[0].length; j++) {
            if(board[i][j]=='O'){
                if ((i == 0 || j == 0 || i == rows - 1 || j == cols - 1) ) {
                    //边界上且为O则吧
                    uf.union(i * cols + j, last);
                }
                else {
                    //吧相连的0结点并起来
                    if (i>0&&board[i - 1][j] == 'O') {
                        uf.union((i-1)*cols+j,i*cols+j);
                    }  if (j>0&&board[i][j - 1] == 'O') {
                        uf.union(i*cols+j-1, i*cols+j);
                    }  if (i<rows-1&&board[i + 1][j] == 'O') {
                        uf.union((i+1)*cols+j, i*cols+j);
                    }  if (j<cols-1&&board[i][j + 1] == 'O') {
                        uf.union(i*cols+j+1, i*cols+j);
                    }
                }
            }

        }
    }
    for(int i=0;i<rows;i++){
        for(int j=0;j<cols;j++){
            if(board[i][j]=='O')
            {
                //只用判断是否与虚拟结点在同一棵树上
                if(uf.isConnected(i*cols+j,last))
                    continue;
                board[i][j]='X';
            }

        }
    }
}

class UF {
    int[] parent;
    int[] size;

    public UF(int n) {
        parent = new int[n];
        size = new int[n];
        for (int i = 0; i < n; i++) {
            parent[i] = i;
            size[i] = 1;
        }
    }

    int find(int p) {
        if (p != parent[p]) {
            return parent[p] = find(parent[p]);
        }
        return p;
    }

    public void union(int p, int q) {
        int proot = find(p);
        int qroot = find(q);
        if (proot == qroot) return;
        if (size[proot] < size[qroot]) {
            parent[proot] = qroot;
            size[qroot] += size[proot];
        } else {
            parent[qroot] = proot;
            size[proot] += size[qroot];
        }
    }

    public boolean isConnected(int p, int q) {
        return find(p) == find(q);
    }
}