leetCode803:打砖块

目录

一、题目描述

二、解题思路

三、代码实现

---

一、题目描述

有一个 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 * 104
• hits[i].length == 2
• 0 <= xi <= m - 1
• 0 <= yi <= n - 1
• 所有 (xi, yi) 互不相同

二、解题思路

这道题是看题解才能相对容易的解出来。因为我还做不到题解那样的细节处理。

本题难在思维。想到跟集合有关不难，难点在于怎么使用并查集，按照题目的说法，敲掉一块之后，需要把这块跟四周的连接断开，然后在判断断开之后跟顶部连接砖块数的减少量。但在集合里断开连接并不是并查集所擅长的。如果反过来想，如果我先把要拆的砖块一开始就全部清零，然后逆序的一块一块加，加的过程中做合并，不就是并查集擅长的了嘛！

过程：

1. 先把要敲掉的砖块全部清零；
2. 把清零后的矩阵做集合的合并操作；
3. 逆序从hits数组一块一块的添加进去，然后更新集合，比较添加前后跟顶端连接砖块数，把差值放进返回数组里

细节：

• 顶部单独用一个序号表示，统一第一行的所有序号。即把第一行的数都跟这个表示顶部的序号进行合并。
• 注意敲掉的砖块是不是非1的格子。原本就不是砖块的格子敲掉前后没有差别。

三、代码实现

/*
 * @Description: 力扣803:打砖块
 * @Version: 2.0
 * @Autor: dcg
 * @Date: 2021-01-08 16:04:57
 * @LastEditors: dcg
 * @LastEditTime: 2021-01-16 12:48:31
 */

#include <bits/stdc++.h>
using namespace std;

vector<int> father;
vector<int> cnt;
vector<int> dx = {1, -1, 0, 0};
vector<int> dy = {0, 0, 1, -1};
void init(int n) {
    for (int i = 0; i < n; i++) {
        father.push_back(i);
        cnt.push_back(1);
    }
}
int findFather(int a) {
    if (a == father[a]) {
        return a;
    }
    int fa = findFather(father[a]);
    father[a] = fa;
    return fa;
}
void Union(int a, int b) {
    int fa = findFather(a);
    int fb = findFather(b);
    if (fa != fb) {
        father[fa] = fb;
        cnt[fb] += cnt[fa];
    }
}
vector<int> hitBricks(vector<vector<int>>& grid, vector<vector<int>>& hits) {
    int r = grid.size();
    int c = grid[0].size();
    init(r * c + 1);
    vector<vector<int>> copy(grid);
    //逆序思维，先把hit数组中的砖块全打碎
    for (auto&& i : hits) {
        copy[i[0]][i[1]] = 0;
    }
    //做集合的合并操作
    for (int j = 0; j < c; j++) {
        if (copy[0][j] == 1) {
            Union(j, r * c);
        }
    }
    for (int i = 1; i < r; i++) {
        for (int j = 0; j < c; j++) {
            if (copy[i][j] == 1) {
                //上方为1
                if (copy[i - 1][j] == 1) {
                    Union(i * c + j, (i - 1) * c + j);
                }
                //左边为1
                if (j > 0 && copy[i][j - 1] == 1) {
                    Union(i * c + j, i * c + j - 1);
                }
            }
        }
    }
    vector<int> res(hits.size());
    for (int i = hits.size() - 1; i >= 0; i--) {
        int pre = cnt[findFather(r * c)];
        int x = hits[i][0];
        int y = hits[i][1];
        //如果原本就是0，则不用管，直接跳过
        if (grid[x][y] == 0) {
            continue;
        }
        if (x == 0) {
            Union(y, r * c);
        }
        for (int i = 0; i < 4; i++) {
            int newX = x + dx[i];
            int newY = y + dy[i];
            if (newX >= 0 && newX < r && newY >= 0 && newY < c &&
                copy[newX][newY] == 1) {
                Union(x * c + y, newX * c + newY);
            }
        }
        int cur = cnt[findFather(r * c)];
        res[i] = max(0, cur - pre - 1);
        copy[x][y] = 1;
    }
    return res;
}

int main() {
    vector<vector<int>> grid = {{1}, {1}, {1}, {1}, {1}};
    vector<vector<int>> hits = {{3, 0},{4, 0},{1, 0},{2, 0},{0,0}};
    //   std::cout << removeStones(stones) << endl;
    vector<int> res = hitBricks(grid, hits);
    for (auto&& i : res) {
        cout << i << " ";
    }

    return 0;
}