LeetCode - 959. 由斜杠划分区域
说明：很明显这是一个求连通分量的问题，最开始我发现将一个格子划分为4个小格子无法求解，但是可以划分为16个小格子，因此划分为16个小格子后的深度/广度优先遍历都可以完成，但是效率很低，我发现讨论里面有同学讲一个格子划分为9个小格子也可以解决，分析了下确认如此，因此方法一，二都是深度/广度优先遍历，分别采用两种划分实现了一遍，不过不管16个格子还是9个格子，效率都较低，最后并查集的方法我没有想到怎么划分和编号以及关联，参考了官方解答后原来是划分为小三角形（而不是小格子正方形，我一直陷落在划分为小格子和编号以及关联上面，不够灵活），方法三为参考官方答案。
描述
在由 1 x 1 方格组成的 N x N 网格 grid 中，每个 1 x 1 方块由 /、\ 或空格构成。这些字符会将方块划分为一些共边的区域。
（请注意，反斜杠字符是转义的，因此 \ 用 "\\" 表示。）。
返回区域的数目。
示例 1：
输入：
[
" /",
"/ "
]
输出：2
解释：2x2 网格如下：
示例 2：
输入：
[
" /",
" "
]
输出：1
解释：2x2 网格如下：
示例 3：
输入：
[
"\\/",
"/\\"
]
输出：4
解释：（回想一下，因为 \ 字符是转义的，所以 "\\/" 表示 \/，而 "/\\" 表示 /\。）
2x2 网格如下：
示例 4：
输入：
[
"/\\",
"\\/"
]
输出：5
解释：（回想一下，因为 \ 字符是转义的，所以 "/\\" 表示 /\，而 "\\/" 表示 \/。）
2x2 网格如下：
示例 5：
输入：
[
"//",
"/ "
]
输出：3
解释：2x2 网格如下：
提示：
1 <= grid.length == grid[0].length <= 30
grid[i][j] 是 '/'、'\'、或 ' '。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/regions-cut-by-slashes/
求解
class UnionFind {
public:
UnionFind(int n) : count(n) {
parent.reserve(count + 1);
for (int i = 0; i <= count; ++i) {
parent.emplace_back(i);
}
rank.resize(count + 1, 1); // 初始每个的层级均为1
}
bool isConnected(int p, int q) {
return find(p) == find(q);
}
void unionElements(int p, int q) {
int proot = find(p);
int qroot = find(q);
if (proot == qroot) {
return;
}
if (rank[proot] < rank[qroot]) {
parent[proot] = qroot;
} else if (rank[proot] > rank[qroot]) {
parent[qroot] = proot;
} else {
// rank[proot] == rank[qroot]
parent[proot] = qroot;
++rank[qroot]; // proot ”挂载“到qroot下面，本来两个层级一致，现在需要增加1
}
}
// 获取连通分量
int getCount() {
int connectCount = 0;
for (int i = 0; i < count; ++i) {
if (parent[i] == i) {
++connectCount;
}
}
return connectCount;
}
private:
int find(int p) {
while (p != parent[p]) {
parent[p] = parent[parent[p]]; // 路径压缩优化，请细品
p = parent[p];
}
return p;
}
private:
std::vector parent;
int count;
std::vector rank;
};
class Solution {
public:
// 方法一，深度遍历求连通分量，将每个单元格划分成16个小单元格，每个小单元格中存在斜线的均填充1，其余填充0
// 低效率通过
int regionsBySlashes_1e_4grids(const vector &grid) {
const int n = grid.size();
// 构造划分后的网格数据，仅包含0,1
vector> grids(4 * n, vector(4 * n, 0));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (grid[i][j] == '/') {
grids[4 * i][4 * j + 3] = 1;
grids[4 * i + 1][4 * j + 2] = 1;
grids[4 * i + 2][4 * j + 1] = 1;
grids[4 * i + 3][4 * j] = 1;
continue;
}
if (grid[i][j] == '\\') {
grids[4 * i][4 * j] = 1;
grids[4 * i + 1][4 * j + 1] = 1;
grids[4 * i + 2][4 * j + 2] = 1;
grids[4 * i + 3][4 * j + 3] = 1;
continue;
}
// 无斜线不处理，初始化中已经将grids初始化为0
}
}
// 深度遍历求连通分量
int count = 0; // 连通分量初始化
gridsNum = grids.size(); // 切分后小栅格为gridsNum * gridsNum
visited.assign(gridsNum, vector(gridsNum, false));
for (int i = 0; i < gridsNum; ++i) {
for (int j = 0; j < gridsNum; ++j) {
if (grids[i][j] == 0 && !visited[i][j]) {
++count;
dfs(grids, i, j);
}
}
}
return count;
}
// 方法一优化，其实将每个单元格切割为9个小单元格就可以解决问题
int regionsBySlashes_1e_3grids(const vector &grid) {
const int n = grid.size();
// 构造划分后的网格数据，仅包含0,1
vector> grids(3 * n, vector(3 * n, 0));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (grid[i][j] == '/') {
grids[3 * i][3 * j + 2] = 1;
grids[3 * i + 1][3 * j + 1] = 1;
grids[3 * i + 2][3 * j] = 1;
continue;
}
if (grid[i][j] == '\\') {
grids[3 * i][3 * j] = 1;
grids[3 * i + 1][3 * j + 1] = 1;
grids[3 * i + 2][3 * j + 2] = 1;
continue;
}
// 无斜线不处理，初始化中已经将grids初始化为0
}
}
// 深度遍历求连通分量
int count = 0; // 连通分量初始化
gridsNum = grids.size(); // 切分后小栅格为gridsNum * gridsNum
visited.assign(gridsNum, vector(gridsNum, false));
for (int i = 0; i < gridsNum; ++i) {
for (int j = 0; j < gridsNum; ++j) {
if (grids[i][j] == 0 && !visited[i][j]) {
++count;
dfs(grids, i, j);
}
}
}
return count;
}
// 方法二，广度遍历求连通分量，将每个单元格划分成16个小单元格，每个小单元格中存在斜线的均填充1，其余填充0
// 低效率通过
int regionsBySlashes_2e_4grids(const vector &grid) {
const int n = grid.size();
// 构造划分后的网格数据，仅包含0,1
vector> grids(4 * n, vector(4 * n, 0));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (grid[i][j] == '/') {
grids[4 * i][4 * j + 3] = 1;
grids[4 * i + 1][4 * j + 2] = 1;
grids[4 * i + 2][4 * j + 1] = 1;
grids[4 * i + 3][4 * j] = 1;
continue;
}
if (grid[i][j] == '\\') {
grids[4 * i][4 * j] = 1;
grids[4 * i + 1][4 * j + 1] = 1;
grids[4 * i + 2][4 * j + 2] = 1;
grids[4 * i + 3][4 * j + 3] = 1;
continue;
}
// 无斜线不处理，初始化中已经将grids初始化为0
}
}
// 广度遍历求连通分量
int count = 0; // 连通分量初始化
gridsNum = grids.size(); // 切分后小栅格为gridsNum * gridsNum
visited.assign(gridsNum, vector(gridsNum, false));
std::queue> q;
for (int i = 0; i < gridsNum; ++i) {
for (int j = 0; j < gridsNum; ++j) {
if (visited[i][j] || grids[i][j] == 1) {
continue;
}
++count;
q.emplace(i, j);
visited[i][j] = true;
while (!q.empty()) {
auto[r, c] = q.front();
q.pop();
for (const auto &p : directions) {
int newR = r + p.first;
int newC = c + p.second;
if (newR < 0 || newR >= gridsNum || newC < 0 || newC >= gridsNum) {
// 索引超范围，跳过当前循环
continue;
}
// 访问未访问过且为0的节点
if (!visited[newR][newC] && grids[newR][newC] == 0) {
q.emplace(newR, newC);
visited[newR][newC] = true;
}
}
}
}
}
return count;
}
// 方法一优化，其实将每个单元格切割为9个小单元格就可以解决问题
int regionsBySlashes(const vector &grid) {
const int n = grid.size();
// 构造划分后的网格数据，仅包含0,1
vector> grids(3 * n, vector(3 * n, 0));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (grid[i][j] == '/') {
grids[3 * i][3 * j + 2] = 1;
grids[3 * i + 1][3 * j + 1] = 1;
grids[3 * i + 2][3 * j] = 1;
continue;
}
if (grid[i][j] == '\\') {
grids[3 * i][3 * j] = 1;
grids[3 * i + 1][3 * j + 1] = 1;
grids[3 * i + 2][3 * j + 2] = 1;
continue;
}
// 无斜线不处理，初始化中已经将grids初始化为0
}
}
// 广度遍历求连通分量
int count = 0; // 连通分量初始化
gridsNum = grids.size(); // 切分后小栅格为gridsNum * gridsNum
visited.assign(gridsNum, vector(gridsNum, false));
std::queue> q;
for (int i = 0; i < gridsNum; ++i) {
for (int j = 0; j < gridsNum; ++j) {
if (visited[i][j] || grids[i][j] == 1) {
continue;
}
++count;
q.emplace(i, j);
visited[i][j] = true;
while (!q.empty()) {
auto[r, c] = q.front();
q.pop();
for (const auto &p : directions) {
int newR = r + p.first;
int newC = c + p.second;
if (newR < 0 || newR >= gridsNum || newC < 0 || newC >= gridsNum) {
// 索引超范围，跳过当前循环
continue;
}
// 访问未访问过且为0的节点
if (!visited[newR][newC] && grids[newR][newC] == 0) {
q.emplace(newR, newC);
visited[newR][newC] = true;
}
}
}
}
}
return count;
}
// 方法三，并查集，参考官方答案
// 将每个单元格划分为4个三角形，则总共有4*n*n个小三角形
int regionsBySlashes_3e(const vector &grid) {
const int n = grid.size();
const int triangleNum = 4 * n * n;
UnionFind uf(triangleNum);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
int id = i * n + j; // 原始格子编号
// 当前格子下边三角形2和下边格子三角形0合并
if (i < n - 1) {
int bottom = id + n;
uf.unionElements(4 * id + 2, 4 * bottom);
}
// 当前格子右边三角形1和右边格子三角形3合并
if (j < n - 1) {
int right = id + 1;
uf.unionElements(4 * id + 1, 4 * right + 3);
}
if (grid[i][j] == '/') {
uf.unionElements(4 * id, 4 * id + 3);
uf.unionElements(4 * id + 1, 4 * id + 2);
continue;
}
if (grid[i][j] == '\\') {
uf.unionElements(4 * id, 4 * id + 1);
uf.unionElements(4 * id + 2, 4 * id + 3);
continue;
}
// grid[i][j] == ' '
uf.unionElements(4 * id, 4 * id + 1);
uf.unionElements(4 * id + 1, 4 * id + 2);
uf.unionElements(4 * id + 2, 4 * id + 3);
}
}
return uf.getCount();
}
private:
vector> visited;
vector> directions{
{1, 0},
{0, 1},
{-1, 0},
{0, -1}};
int gridsNum;
// 深度遍历网格
void dfs(const vector> &grids, int r, int c) {
visited[r][c] = true;
for (const auto &p : directions) {
int newR = r + p.first;
int newC = c + p.second;
if (newR < 0 || newR >= gridsNum || newC < 0 || newC >= gridsNum) {
// 索引超范围，跳过当前循环
continue;
}
// 访问未访问过且为0的节点
if (!visited[newR][newC] && grids[newR][newC] == 0) {
dfs(grids, newR, newC);
}
}
}
};