leetcode 959.由斜杠划分区域

题干

在由 1 x 1 方格组成的 N x N 网格 grid 中，每个 1 x 1 方块由 /、\ 或空格构成。这些字符会将方块划分为一些共边的区域。
（请注意，反斜杠字符是转义的，因此 \ 用 “\” 表示。）。
返回区域的数目。

示例 1：
输入：
[
  " /",
  "/ "
]
输出：2

示例 2：
输入：
[
  " /",
  " "
]
输出：1

示例 3：
输入：
[
  “\/”,
  “/\”
]
输出：4
解释：（回想一下，因为 \ 字符是转义的，所以 “\/” 表示 /，而 “/\” 表示 /\。）

示例 4：
输入：
[
  “/\”,
  “\/”
]
输出：5
解释：（回想一下，因为 \ 字符是转义的，所以 “/\” 表示 /\，而 “\/” 表示 /。）

示例 5：
输入：
[
  “//”,
  "/ "
]
输出：3

提示：
1 <= grid.length == grid[0].length <= 30
grid[i][j] 是 ‘/’、’’、或 ’ '。

题解

用并查集的思路，把每个1x1方块划分为左三角和右三角，并将连通的三角设置同样的祖先，本质还是求连通分支的个数

class Solution {
public:

    //寻找最大祖先，并返回最大祖先在ancestor数组中的下标，没有祖先返回-1
    int findAncestor(int n,vector<int>& ancestor){
        while(ancestor[n] != n){
            n = ancestor[n];
        }
        return n;
    }

    //获得给定坐标方块的对应三角块在祖先数组中的下标
    int getLeftTriangle(vector<string>& grid,int x,int y,int n){
        return 2 * x * n + y * 2;
    }

    int getRightTriangle(vector<string>& grid,int x,int y,int n){
        return 2 * x * n + y * 2 + 1;
    }

    int getUpperTriangle(vector<string>& grid,int x,int y,int n){
        if(grid[x][y] == '/'){
        //斜杠方块的上三角是左三角
            return 2 * x * n + y * 2;
        }else{
            return 2 * x * n + y * 2 + 1;
        }
    }

    int getLowerTriangle(vector<string>& grid,int x,int y,int n){
        if(grid[x][y] == '/'){
        //斜杠方块的下三角是右三角
            return 2 * x * n + y * 2 + 1;
        }else{
            return 2 * x * n + y * 2;
        }
    }

    int regionsBySlashes(vector<string>& grid) {
        int n = grid.size();
        int components = 0;
        //给每个1x1块的左右小三角一个祖先的空间
        vector<int> ancestor(2000,-1);
        for(int i = 0 ; i < n ; ++i){
            for(int j = 0 ; j < n ; ++j){
                int currentLeftTri = getLeftTriangle(grid,i,j,n);
                int currentRightTri = getRightTriangle(grid,i,j,n);
                int preLeftTri = getLeftTriangle(grid,i,j-1,n);
                int preRightTri = getRightTriangle(grid,i,j-1,n);
                //现将当前方块的左右三角的祖先都设为自己
                ancestor[currentLeftTri] = currentLeftTri;
                components++;
                ancestor[currentRightTri] = currentRightTri;
                components++;

                if(grid[i][j] == ' '){
                //当前方块没有斜杠，左右连通
                    if(findAncestor(currentLeftTri,ancestor) != findAncestor(currentRightTri,ancestor) ){
                    //当前方块右三角和左三角的祖先不同，将当前方块右三角的最大祖先的祖先设为左三角的最大祖先
                        ancestor[findAncestor(currentRightTri,ancestor)] = findAncestor(currentLeftTri,ancestor);
                        components--;
                    }
                }

                if(j != 0){
                //此时不是第一列，左三角和左侧方块右三角连通
                    if(findAncestor(preRightTri,ancestor) != findAncestor(currentLeftTri,ancestor) ){
                    //左侧方块右三角和当前方块左三角祖先不同,将当前方块左三角的最大祖先的祖先设为左侧方块右三角的最大祖先
                        ancestor[findAncestor(currentLeftTri,ancestor)] = findAncestor(preRightTri,ancestor);
                        components--;
                    }
                }

                if(i != 0){
                //此时不是第一行，上三角和上册方块下三角连通
                int upperLowerTri = getLowerTriangle(grid,i-1,j,n);
                int currentUpperTri = getUpperTriangle(grid,i,j,n);
                    if(findAncestor(upperLowerTri,ancestor) != findAncestor(currentUpperTri,ancestor) ){
                    //上侧方块下三角和当前方块祖先不同，将当前方块上三角的最大祖先的祖先设为上侧方块下三角的最大祖先
                        ancestor[findAncestor(currentUpperTri,ancestor)] = findAncestor(upperLowerTri,ancestor);
                        components--;
                    }
                }
            }
        }
        return components;
    }
};