【每日一题】 959. 由斜杠划分区域
避免每日太过咸鱼，一天搞定一道LeetCode算法题
一、题目描述
在由 1 x 1 方格组成的 N x N 网格 grid 中，每个 1 x 1 方块由 /、\ 或空格构成。这些字符会将方块划分为一些共边的区域。（请注意，反斜杠字符是转义的，因此 \ 用 “\” 表示。）。
返回区域的数目。
提示：
1 <= grid.length == grid[0].length <= 30grid[i][j]是'/'、'\'、或' '。
示例 1：
输入：
[
" /",
"/ "
]
输出：2
解释：2x2 网格如下：
示例 2：
输入：
[
" /",
" "
]
输出：1
解释：2x2 网格如下：
示例 3：
输入：
[
"\\/",
"/\\"
]
输出：4
解释：（回想一下，因为 \ 字符是转义的，所以 "\\/" 表示 \/，而 "/\\" 表示 /\。）
2x2 网格如下：
示例 4：
输入：
[
"/\\",
"\\/"
]
输出：5
解释：（回想一下，因为 \ 字符是转义的，所以 "/\\" 表示 /\，而 "\\/" 表示 \/。）
2x2 网格如下：
示例 5：
输入：
[
"//",
"/ "
]
输出：3
解释：2x2 网格如下：
二、题解
1. 解法
解题思路：
这是一个关于连通性的问题，让我们求解连通分量的个数，解决这个问题没有特别的技巧，根据题意 画图分析、稍微细心一点就可以通过系统测评。
可以用深度优先遍历（Depth First Search）、广度优先遍历（Breadth First Search）和并查集（Disjoint Sets），由于只要求计算结果，不要求给出具体的连通信息，可以使用并查集。
1. 并查集
「斜杠」、「反斜杠」把单元格拆分成的 2 个三角形的形态，在做合并的时候需要分类讨论。根据「斜杠」、「反斜杠」分割的特点，我们把一个单元格分割成逻辑上的 4 个部分。如下图所示：
我们须要遍历一次输入的二维网格 grid，在 单元格内 和 单元格间 进行合并。
单元格内：
如果是空格：合并 0、1、2、3；
如果是斜杠：合并 0、3，合并 1、2；
如果是反斜杠：合并 0、1，合并 2、3。
单元格间：
把每一个单元格拆分成 4 个小三角形以后，相邻的单元格须要合并，无须分类讨论。我们选择在遍历 grid 的每一个单元格的时候，分别「向右、向下」尝试合并。
向右：合并 1 （当前单元格）和 3（当前单元格右边 1 列的单元格），上图中红色部分；
向下：合并 2 （当前单元格）和 0（当前单元格下边 1 列的单元格），上图中蓝色部分。
事实上，大家选择在遍历 grid 的每一个单元格的时候，分别「向左、向上」、「向左、向下」、「向右、向上」、「向右、向下」中的任何一种都可以。
合并完成以后，并查集里连通分量的个数就是题目要求的区域的个数。
java代码实现如下：
public static int regionsBySlashes(String[] grid) {
int n = grid.length;
int size = 4 * n * n;
UnionFind unionFind = new UnionFind(size);
for (int i = 0; i < n; i++) {
char[] chars = grid[i].toCharArray();
for (int j = 0; j < chars.length; j++) {
// 二维网格转换为一维表格
int index = 4 * (i * n + j);
char c = chars[j];
// 单元格内合并
if (c == '/') {
// 合并 0、3，合并 1、2
unionFind.union(index, index + 3);
unionFind.union(index + 1, index + 2);
} else if (c == '\\') {
// 合并 0、1，合并 2、3
unionFind.union(index, index + 1);
unionFind.union(index + 2, index + 3);
} else {
unionFind.union(index, index + 1);
unionFind.union(index + 1, index + 2);
unionFind.union(index + 2, index + 3);
}
// 单元格间合并
// 向右合并：1（当前）、3（右一列）
if (j + 1 < n) {
unionFind.union(index + 1, 4 * (i * n + j + 1) + 3);
}
// 向下合并：2（当前）、0（下一行）
if (i + 1 < n) {
unionFind.union(index + 2, 4 * ((i + 1) * n + j));
}
}
}
return unionFind.getCount();
}
private static class UnionFind {
private int[] parent;
private int count;
public int getCount() {
return count;
}
public UnionFind(int n) {
this.count = n;
this.parent = new int[n];
for (int i = 0; i < n; i++) {
parent[i] = i;
}
}
public int find(int x) {
return parent[x] == x ? x : (parent[x] = find(parent[x]));
}
public void union(int x, int y) {
int rootX = find(x);
int rootY = find(y);
if (rootX == rootY) {
return;
}
parent[rootX] = rootY;
count--;
}
}
复杂度分析
-
时间复杂度：O(m⋅α(n))，其中 mm 是数组 connections 的长度，α 是阿克曼函数的反函数。
-
空间复杂度：O(n)，即为并查集需要使用的空间。
2. 解法二
做题不是目的，毕竟这道题用并查集做出来也是比较ok的了，但是为了学习更多的算法思想，所以看看大佬们其他的解决方案，了解到了 深度优先搜索 ，接下来我们就是这个试一下吧。使用深度优先搜索来得到图中的连通分量数。
具体地，初始时所有节点的状态均为「待搜索」。我们每次选择一个「待搜索」的节点，从该节点开始进行深度优先搜索，并将所有搜索到的节点的状态更改为「已搜索」，这样我们就找到了一个连通分量。
List<Integer>[] edges;
boolean[] used;
public int makeConnected2(int n, int[][] connections) {
if (connections.length < n - 1) {
return -1;
}
edges = new List[n];
for (int i = 0; i < n; ++i) {
edges[i] = new ArrayList<Integer>();
}
for (int[] conn : connections) {
edges[conn[0]].add(conn[1]);
edges[conn[1]].add(conn[0]);
}
used = new boolean[n];
int ans = 0;
for (int i = 0; i < n; ++i) {
if (!used[i]) {
dfs(i);
++ans;
}
}
return ans - 1;
}
public void dfs(int u) {
used[u] = true;
for (int v : edges[u]) {
if (!used[v]) {
dfs(v);
}
}
}
复杂度分析
-
时间复杂度：O(n+m)，其中 m 是数组 connections 的长度。
-
空间复杂度：O(n+m)，其中 O(m) 为存储所有边需要的空间，O(n) 为深度优先搜索中使用的栈空间。
题目来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/distance-between-bus-stops
--------------最后感谢大家的阅读，愿大家技术越来越流弊！--------------
--------------也希望大家给我点支持，谢谢各位大佬了！！！--------------