打砖块

有一个 $m\times n$ 的二元网格，其中 $1$ 表示砖块，$0$ 表示空白。砖块 稳定（不会掉落）的前提是：

一块砖直接连接到网格的顶部，或者
至少有一块相邻（$4$ 个方向之一）砖块 稳定 不会掉落时
给你一个数组 $hits$ ，这是需要依次消除砖块的位置。每当消除 $hits[i]=(ro{w}_i,co{l}_i)$ 位置上的砖块时，对应位置的砖块（若存在）会消失，然后其他的砖块可能因为这一消除操作而掉落。一旦砖块掉落，它会立即从网格中消失（即，它不会落在其他稳定的砖块上）。

返回一个数组 $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] 。

提示：

$$\begin{gathered} m==grid.length \\ n==grid[i].length \\ 1<=m,n<=200 \end{gathered}$$
$grid[i][j]$为 $0$ 或 $1$
$$\begin{gathered} 1<=hits.length<=4\ast 10^4 \\ hits[i].length==2 \\ 0<=x_i<=m-1 \\ 0<=y_i<=n-1 \end{gathered}$$
所有 ($x_i,y_i$) 互不相同

class Solution {
public:
    int f[40010],siz[40010];
    int find(int x){
        return x==f[x]?x:f[x]=find(f[x]);
    }
    void unit(int x,int y){
        x=find(x);
        y=find(y);
        if (x==y) return;
        f[x]=y;
        siz[y]+=siz[x];
    }
    int getsize(int x){
        return siz[find(x)];
    }
    vector<int> hitBricks(vector<vector<int>>& grid, vector<vector<int>>& hits) {
        vector<int>res(hits.size(),0);
        vector<vector<int>>state=grid;
        int n=grid.size(),m=grid[0].size();
        for (auto &it:hits){
            state[it[0]][it[1]]=0;
        }
        for (int i=0;i<40010;i++) {
            siz[i]=1;
            f[i]=i;
        }
        int p=n*m;
        for (int i=0;i<n;i++){
            for (int j=0;j<m;j++){
                if  (state[i][j]==1){
                    if (i==0){
                        unit(i*m+j,p);
                    }
                    if (i>0&&state[i-1][j]==1){
                        unit((i-1)*m+j,i*m+j);
                    }
                    if (j>0&&state[i][j-1]==1){
                        unit(i*m+j-1,i*m+j);
                    }
                }
            }
        }
        const vector<pair<int,int> >dir={{1,0},{-1,0},{0,1},{0,-1}};
        for (int i=hits.size()-1;i>=0;i--){
            int x=hits[i][0],y=hits[i][1];
            if (grid[x][y]==0) continue;
            int pre=getsize(p);
            if (x==0){
                unit(x*m+y,p);
            }
            for (auto &[dx,dy]:dir){
                int x1=x+dx,y1=y+dy;
                if (x1>=0&&y1>=0&&x1<n&&y1<m&&state[x1][y1]==1){
                    unit(x1*m+y1,x*m+y);
                }
            }
            res[i]=max(0,getsize(p)-pre-1);
            state[x][y]=1;
        }
        return res;
    }
};