有一个 m x n
的二元网格,其中 1
表示砖块,0
表示空白。砖块 稳定(不会掉落)的前提是:
- 一块砖直接连接到网格的顶部,或者
- 至少有一块相邻(4 个方向之一)砖块 稳定 不会掉落时
给你一个数组 hits
,这是需要依次消除砖块的位置。每当消除 hits[i] = (rowi, coli)
位置上的砖块时,对应位置的砖块(若存在)会消失,然后其他的砖块可能因为这一消除操作而掉落。一旦砖块掉落,它会立即从网格中消失(即,它不会落在其他稳定的砖块上)。
返回一个数组 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 * 10^4
hits[i].length == 2
0 <= xi <= m - 1
0 <= yi <= n - 1
- 所有
(xi, yi)
互不相同
解答
这道题能够直观想到使用并查集,但是并查集通常只能正向将不同分支合并,而不能将属于同一个根节点地分量拆分为不同分支,因此需要采取逆向思维。具体解答参照官方题解link:
class UnionFind {
private:
vector<int> f, sz;
public:
// sz[i]记录以节点i为根的连通分量所包含的节点个数
UnionFind(int n): f(n), sz(n) {
for (int i = 0; i < n; i++) {
f[i] = i;
sz[i] = 1;
}
}
int find(int x) {
if (f[x] == x) {
return x;
}
int newf = find(f[x]);
f[x] = newf;
return f[x];
}
void merge(int x, int y) {
int fx = find(x), fy = find(y);
if (fx == fy) {
return;
}
f[fx] = fy;
// 合并时需要对连通分量中节点个数一并合并处理
sz[fy] += sz[fx];
}
// 返回包含节点x的连通分量中所包含的节点个数
int size(int x) {
return sz[find(x)];
}
};
class Solution {
public:
vector<int> hitBricks(vector<vector<int>>& grid, vector<vector<int>>& hits) {
int h = grid.size(), w = grid[0].size();
// [i, j] 映射为 i * w + j
// 将虚拟节点 h * w 作为顶部砖块的祖先
UnionFind uf(h * w + 1);
vector<vector<int>> status = grid;
// 先将hits中要消除的砖块置零(不包括掉落的砖块)
for (int i = 0; i < hits.size(); i++) {
status[hits[i][0]][hits[i][1]] = 0;
}
// 建立消除hits中砖块后的连通图
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (status[i][j] == 1) {
if (i == 0) {
uf.merge(h * w, i * w + j);
}
if (i > 0 && status[i - 1][j] == 1) {
uf.merge(i * w + j, (i - 1) * w + j);
}
if (j > 0 && status[i][j - 1] == 1) {
uf.merge(i * w + j, i * w + j - 1);
}
}
}
}
// 此时没有与根节点 h * w 连通的那些砖块将会掉落
const vector<pair<int, int>> directions{{0, 1},{1, 0},{0, -1},{-1, 0}};
vector<int> ret(hits.size(), 0);
for (int i = hits.size() - 1; i >= 0; i--) {
int r = hits[i][0], c = hits[i][1];
if (grid[r][c] == 0) {
continue;
}
// 统计消除hits[i]砖块后的连通分量个数
int prev = uf.size(h * w);
if (r == 0) {
uf.merge(c, h * w);
}
for (const auto [dr, dc]: directions) {
int nr = r + dr, nc = c + dc;
if (nr >= 0 && nr < h && nc >= 0 && nc < w) {
if (status[nr][nc] == 1) {
uf.merge(r * w + c, nr * w + nc);
}
}
}
// 统计消除hits[i]砖块前的连通分量个数
int size = uf.size(h * w);
ret[i] = max(0, size - prev - 1);
status[r][c] = 1;
}
return ret;
}
};
// 作者:LeetCode-Solution
// 链接:https://leetcode-cn.com/problems/bricks-falling-when-hit/solution/da-zhuan-kuai-by-leetcode-solution-szrq/
// 来源:力扣(LeetCode)
// 著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。