959.由斜杠划分区域

题目

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

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

返回区域的数目。

示例1

输入：
[
  " /",
  "/ "
]
输出：2
解释：2x2 网格如下：

示例2

输入：
[
  " /",
  "  "
]
输出：1
解释：2x2 网格如下：

示例3

输入：
[
  "\\/",
  "/\\"
]
输出：4
解释：（回想一下，因为 \ 字符是转义的，所以 "\\/" 表示 \/，而 "/\\" 表示 /\。）
2x2 网格如下：

题解

1. 题目的意思：每个1x1的正方形被/和\\分割，输入的数组grid代表一个NxN的正方形，求分割后的区域的个数
2. 对于每一个1x1的正方形，其两条对角线能将其分割为4个区域，也就是4个三角形，把NxN的正方形看作分离的N个1x1的正方形，那么我们对每一个1x1的三角形都采取斜杠和反斜杠的分割特点

1. 如果是空格，则合并四个区域
2. 如果是斜杠：合并0，3和1，2区域
3. 如果是反斜杠：合并0，1和2，3区域

3. 单个的1x1的正方形的情况结束了，若两个1x1的正方形堆积在一起形成一个1x2或者2x1的矩形时，我们仍需要合并区间

1. 形成2x1矩形时：向右合并，如图红色区域
2. 形成1x2矩形时：向左合并，如图蓝色区域

4. 合并完之后就得到了结果

参考代码：

class Solution {
    public int regionsBySlashes(String[] grid) {
      int N = grid.length;
      int count = 4 * N * N;
      UnionFind myUnion = new UnionFind(count);
      for (int i = 0; i < N; i++) {
            char[] row = grid[i].toCharArray();
            for (int j = 0; j < N; j++) {
                // 二维网格转换为一维表格
                int index = 4 * (i * N + j);
                char c = row[j];
                // 单元格内合并
                if (c == '/') {
                    // 合并 0、3，合并 1、2
                    myUnion.union(index, index + 3);
                    myUnion.union(index + 1, index + 2);
                } else if (c == '\\') {
                    // 合并 0、1，合并 2、3
                    myUnion.union(index, index + 1);
                    myUnion.union(index + 2, index + 3);
                } else {
                    myUnion.union(index, index + 1);
                    myUnion.union(index + 1, index + 2);
                    myUnion.union(index + 2, index + 3);
                }

                // 单元格间合并
                // 向右合并：1（当前）、3（右一列）
                if (j + 1 < N) {
                    myUnion.union(index + 1, 4 * (i * N + j + 1) + 3);
                }
                // 向下合并：2（当前）、0（下一行）
                if (i + 1 < N) {
                    myUnion.union(index + 2, 4 * ((i + 1) * N + j));
                }
            }
        }
      return myUnion.getCount();
    }

    private class UnionFind {
        int[] parent;
        int[] rank;
        int count;

        public int getCount() {
          return count;
        }

        public UnionFind(int n) {
            parent = new int[n];
            rank = new int[n];
            this.count = n;
            for(int i = 0; i < n; i++) {
                parent[i] = i;
                rank[i] = 1;
            }
        }
        // 按秩合并
        public boolean union(int a, int b) {
            int rootA = find(a);
            int rootB = find(b);
            if(rootA != rootB) {
                if(rank[rootA] < rank[rootB]) {
                    parent[rootA] = rootB;
                } else {
                    if(rank[rootA] == rank[rootB]) {
                        rank[rootA]++;
                    }
                    parent[rootB] = rootA;
                }
                count--;
            } else {
                return false;
            }
            return true;
        }
        // 路径压缩
        public int find(int index) {
            if(parent[index] != index) {
                return find(parent[index]);
            }
            return parent[index];
        }
    }
}