一、题目
有一个 m x n 的二元网格 grid ,其中 1 表示砖块,0 表示空白。砖块 稳定(不会掉落)的前提是:
一块砖直接连接到网格的顶部,或者
至少有一块相邻(4 个方向之一)砖块 稳定 不会掉落时
给你一个数组 hits ,这是需要依次消除砖块的位置。每当消除 hits[i] = (rowi, coli) 位置上的砖块时,对应位置的砖块(若存在)会消失,然后其他的砖块可能因为这一消除操作而 掉落 。一旦砖块掉落,它会 立即 从网格 grid 中消失(即,它不会落在其他稳定的砖块上)。
返回一个数组 result ,其中 result[i] 表示第 i 次消除操作对应掉落的砖块数目。
注意,消除可能指向是没有砖块的空白位置,如果发生这种情况,则没有砖块掉落。
示例 1:
输入:grid = [[1,0,0,0],[1,1,1,0]], hits = [[1,0]]
输出:[2]
解释:网格开始为:
[[1,0,0,0],
[1,1,1,0]]
消除 (1,0) 处加粗的砖块,得到网格:
[[1,0,0,0]
[0,1,1,0]]
两个加粗的砖不再稳定,因为它们不再与顶部相连,也不再与另一个稳定的砖相邻,因此它们将掉落。得到网格:
[[1,0,0,0],
[0,0,0,0]]
因此,结果为 [2] 。
示例 2:
输入:grid = [[1,0,0,0],[1,1,0,0]], hits = [[1,1],[1,0]]
输出:[0,0]
解释:网格开始为:
[[1,0,0,0],
[1,1,0,0]]
消除 (1,1) 处加粗的砖块,得到网格:
[[1,0,0,0],
[1,0,0,0]]
剩下的砖都很稳定,所以不会掉落。网格保持不变:
[[1,0,0,0],
[1,0,0,0]]
接下来消除 (1,0) 处加粗的砖块,得到网格:
[[1,0,0,0],
[0,0,0,0]]
剩下的砖块仍然是稳定的,所以不会有砖块掉落。
因此,结果为 [0,0] 。
提示:
- m == grid.length
- n == grid[i].length
- 1 <= m, n <= 200
- grid[i][j] 为 0 或 1
- 1 <= hits.length <= 4 * 104
- hits[i].length == 2
- 0 <= xi <= m - 1
- 0 <= yi <= n - 1
- 所有 (xi, yi) 互不相同
二、代码
class Solution {
public int[] hitBricks(int[][] grid, int[][] hits) {
// 将炮弹达到对应的砖块上,并将该位置标记为2
for (int i = 0; i < hits.length; i++) {
// 只需要将有方块的地方标记为2,如果该位置是0,不用标记
if (grid[hits[i][0]][hits[i][1]] == 1) {
grid[hits[i][0]][hits[i][1]] = 2;
}
}
// 用已经被炮弹打完的二维数组初始化构建并查集
UnionFind unionFind = new UnionFind(grid);
// 逆操作,逆向还原二维数组并统计坠落的砖块数
int[] ans = new int[hits.length];
for (int i = hits.length - 1; i >= 0; i--) {
// 只有被炮弹打中的砖块才需要恢复
if (grid[hits[i][0]][hits[i][1]] == 2) {
// 恢复砖块,并且计算坠落砖块的数量
ans[i] = unionFind.recoveryAndGetFallCount(hits[i][0], hits[i][1]);
}
}
// 返回答案
return ans;
}
public class UnionFind{
// 二维数组的行数
private int n;
// 二维数组的列数
private int m;
// 二维数组,注意是地址传递
private int[][] grid;
// 此时连接着天花板的所有集合的总砖块数
private int cellingAll;
// 标记当前集合是否为连接着天花板的集合,下标为结合的代表节点数据才是有效的
// isCellingSet[i] = true:i 是集合的代表,以i为代表节点的集合是天花板集合
private boolean[] isCellingSet;
// 父节点集合,记录每个位置的父节点,这个父节点有可能经历路线压缩后,就不再是直接父节点了
// parents[cur] = x:cur的父节点为x
private int[] parents;
// 记录每个集合的大小,只有下标为代表节点的时候数据才是有效的
// setSize[cur] = 10:代表节点为cur的集合大小为10
private int[] setSize;
// 用来进行路径压缩的栈。这个栈一定要在初始化并查集的时候就创建好,
// 然后在后续的多次路径压缩的过程中就可以直接复用这个栈数组了,避免了多次申请创建数组的过程,可以大大减少性能损耗
private int[] stack;
public UnionFind(int[][] grid) {
// 初始化并查集的成员属性
this.grid = grid;
this.n = grid.length;
this.m = grid[0].length;
// 二维数组一共有多少个格子
int all = n * m;
this.isCellingSet = new boolean[all];
this.parents = new int[all];
this.setSize = new int[all];
this.cellingAll = 0;
// 这里要注意,要在并查集初始化阶段提前将栈数组创建为成员变量,避免后续的路径压缩过程中反复的申请创建,降低代码性能
this.stack = new int[n * m];
// 将所有还没有被炮弹打到的砖块单独创建一个集合
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
// 将所有为1的砖块单独创建一个集合
if (grid[i][j] == 1) {
// 二位下表转为一维下标
int cur = i * m + j;
// 自己是自己的父节点
parents[cur] = cur;
// 自己的集合大小为1
setSize[cur] = 1;
// 如果是连接着天花板的,也记录为天花板集合,并且将连接天花板的砖块数量加1
if (i == 0) {
isCellingSet[cur] = true;
cellingAll++;
}
}
}
}
// 初始完了所有集合之后,去进行每个独立集合的合并,将相互连通的集合进行合并
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
// 每个位置都尝试与自己上下左右四个位置的节点集合合并
union(i, j, i - 1, j);
union(i, j, i + 1, j);
union(i, j, i, j - 1);
union(i, j, i, j + 1);
}
}
}
// 查找指定节点所在集合的代表节点
public int find(int row, int col) {
// 标记栈顶
int top = -1;
// 二维转一维
int cur = row * m + col;
// 先找到记录在数组中的父节点,然后沿着父节点继续向上遍历
int father = parents[cur];
// 沿着父节点路线向上遍历,当遍历到的节点的父节点还是自己,说明找到了代表节点了
while (cur != father) {
// 将沿途的节点都记录到栈里
stack[++top] = cur;
// 向后遍历
cur = father;
father = parents[father];
}
// 将栈中刚刚途径的节点的父节点都设置成找到的代表节点,完成路径压缩
while (top != -1) {
parents[stack[top--]] = father;
}
// 返回代表节点
return father;
}
// 将两个位置所在集合进行合并
public void union(int r1, int c1, int r2, int c2) {
if (valid(r1, c1) && valid(r2, c2)) {
// 找到两个点所在集合的代表节点
int representativeNode1 = find(r1, c1);
int representativeNode2 = find(r2, c2);
// 判断两个集合是否为同一个集合
if (representativeNode1 != representativeNode2) {
// 获取集合大小以及该集合是否为连接着天花板的集合
int setSize1 = setSize[representativeNode1];
int setSize2 = setSize[representativeNode2];
boolean isCelling1 = isCellingSet[representativeNode1];
boolean isCelling2 = isCellingSet[representativeNode2];
// 将小集合并入到大集合中,也能压缩路径
if (setSize1 > setSize2) {
// 将小集合的代表节点设置为大集合的节点
parents[representativeNode2] = representativeNode1;
// 增加大集合数量
setSize[representativeNode1] += setSize2;
// 如果两个集合存在一个连接天花板的集合(两个集合的状态不同,就一定需要更新天花板集合信息),那么合并后的集合必然也是一个天花板集合
// 更新连接天花板集合的大小,并且将合并后的集合设置为天花板集合
if (isCelling1 ^ isCelling2) {
isCellingSet[representativeNode1] = true;
cellingAll += isCelling1 ? setSize2 : setSize1;
}
} else {
parents[representativeNode1] = representativeNode2;
setSize[representativeNode2] += setSize1;
if (isCelling1 ^ isCelling2) {
isCellingSet[representativeNode2] = true;
cellingAll += isCelling1 ? setSize2 : setSize1;
}
}
}
}
}
// 判断位置是否有效,其中包括判断该位置是否为1
public boolean valid(int row, int col) {
return row >= 0 && row < n && col >= 0 && col < m && grid[row][col] == 1;
}
// 恢复砖块,并且计算坠落砖块的数量
public int recoveryAndGetFallCount(int row, int col) {
// 将当前位置恢复为1
grid[row][col] = 1;
// 二维转一维
int cur = row * m + col;
// 如果恢复之后的砖块正好连着天花板,就将其设置为一个天花板集合
if (row == 0) {
cellingAll++;
isCellingSet[cur] = true;
}
// 为其单独创建一个集合
parents[cur] = cur;
setSize[cur] = 1;
// 将当前天花板集合的砖块总数量记录为preCnt
int preCnt = cellingAll;
// 将恢复的位置与其上下左右的集合进行合并
union(row, col, row - 1, col);
union(row, col, row + 1, col);
union(row, col, row, col - 1);
union(row, col, row, col + 1);
// 记录合并完之后天花板集合的砖块总数量
int nowCnt = cellingAll;
// 如果恢复的位置就在天花板上
if (row == 0) {
return nowCnt - preCnt;
// 如果恢复的位置不在天花板上
} else {
// 有可能恢复的位置是一个完全不连着天花板的砖块,所以有可能preCnt==nowCnt,这种情况直接返回0
return preCnt == nowCnt ? 0 : nowCnt - preCnt - 1;
}
}
}
}
三、解题思路
这道题的关键点是要逆着恢复。
为什么逆着来?因为之前的发生都比后面的早,之前炮弹的影响要保留下来影响后面的炮弹。
倒着来,之前炮弹留下的洞都保留着,之前发生的炮弹我给它设置为2了,该掉的它接不上的已经接不上了。此时因为我2改1能接上去多少个砖,就代表着我当初后面发射的炮弹的情况下,打掉多少块砖,完全保留了在之前发射的保单已经掉了的砖块,之前掉的转款肯定就已经接不上了。