leetcode —— 959. 由斜杠划分区域

在由 1 x 1 方格组成的 N x N 网格 grid 中，每个 1 x 1 方块由 /、\ 或空格构成。这些字符会将方块划分为一些共边的区域。

（请注意，反斜杠字符是转义的，因此 \ 用 “\” 表示。）。

返回区域的数目。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/regions-cut-by-slashes
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
————————————
解题方法（一）——DFS深度遍历：

构造一个len(grid)len(grid)的小方格矩阵，每个小方格由33的小方格组成。根据grid给定的字符串，对构造的小方格矩阵进行更新，对于出现斜边的小方格，将其值标记为1。

然后使用深度遍历进行查询。

class Solution:
    def __init__(self):
        self.ans = 0
    def regionsBySlashes(self, grid: List[str]) -> int:
        length = len(grid)
        # 构造进行深度遍历的小方格矩阵
        grids = [[0 for _ in range(length*3)] for _ in range(length*3)]
        # 基于给定的grid修改小方格中的值
        # 在出现斜边的位置将其值标记为1
        for i in range(length):
            for j in range(length):
                if grid[i][j] == '\\':
                    grids[i*3][j*3] = 1
                    grids[i*3+1][j*3+1] = 1
                    grids[i*3+2][j*3+2] = 1
                if grid[i][j] == '/':
                    grids[i*3][j*3+2] = 1
                    grids[i*3+1][j*3+1] = 1
                    grids[i*3+2][j*3] = 1
        
        # 深度优先遍历递归函数
        def dfs(grids,i,j):
            grids[i][j] = 1
            for x,y in [[i-1,j],[i+1,j],[i,j-1],[i,j+1]]:
                if x<0 or x==3*length or y<0 or y==3*length or grids[x][y] == 1:
                    continue
                dfs(grids,x,y)
                
        for i in range(length*3):
            for j in range(length*3):
                if grids[i][j] == 0:
                    self.ans += 1
                    dfs(grids,i,j)
        return self.ans

解题方法（二）—— 并查集（https://leetcode-cn.com/problems/regions-cut-by-slashes/solution/959-you-xie-gang-hua-fen-qu-yu-guan-fang-de-ti-jie/）

class Solution:
    def regionsBySlashes(self, grid: List[str]) -> int:
        N = len(grid)
        parent = [i for i in range(4 * N * N)] # 开始的时候每个节点的帮主都是自己
        def find(parent, x): # 寻找每个节点的帮主
            if parent[x] == x:
                return parent[x]
            return find(parent, parent[x])
        
        def union(parent, x, y): # 两个人相遇， 那么各自去找教主，教主对决
            x_root = find(parent, x)
            y_root = find(parent, y)
            if x_root != y_root: # 教主不同
                parent[x_root] = y_root # 对决赢的成为新教主
        
        def union_find(grid):
            for r, row in enumerate(grid):
                for c, val in enumerate(row):
                    top = 4 * (r * N + c) 
                    # 将一个方格内的连通单元进行拼接
                    if val in ['/', ' ']:
                        union(parent, top + 0, top + 1)
                        union(parent, top + 2, top + 3)
                    if val in ['\\', ' ']:
                        union(parent, top + 0, top + 2)
                        union(parent, top + 1, top + 3)
                    # 将单元件的连通单元进行拼接
                    if r + 1 < N: 
                        union(parent, top + 3, top + (4 * N) + 0)
                    if r - 1 >= 0:# 这部分其实是多于的
                        union(parent, top + 0, top - (4 * N) + 3) 
                    if c + 1 < N:
                        union(parent, top + 2, top + 4 + 1)
                    if c - 1 >= 0: # 这部分其实也是多于的
                        union(parent, top + 1, top - 4 + 2)

            return sum(parent[x] == x for x in range(4 * N * N ))
        return union_find(grid)