[leetcode] 554. Brick Wall dfs超时并查集【1】

最新推荐文章于 2025-02-06 20:15:34 发布

qiang_____0712

最新推荐文章于 2025-02-06 20:15:34 发布

阅读量265

点赞数 1

CC 4.0 BY-SA版权

分类专栏：程序片段文章标签： dfs 并查集

本文链接：https://blog.youkuaiyun.com/qiang_____0712/article/details/86261530

程序片段专栏收录该内容

107 篇文章

订阅专栏

本文深入探讨了LeetCode中一道关于砖块消除的算法题目，通过详细的示例和代码实现，讲解了如何使用深度优先搜索（DFS）和并查集（Disjoint Set Union，DSU）来解决砖块消除后的影响问题，包括砖块是否能保持不掉落的状态及每次消除后落下的砖块数量。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

https://leetcode-cn.com/problems/bricks-falling-when-hit/submissions/

我们有一组包含1和0的网格；其中1表示砖块。当且仅当一块砖直接连接到网格的顶部，或者它至少连接着(4个方向)相邻的砖块之一时，它才不会落下。

我们会依次消除一些砖块。每当我们消除 (i, j) 位置时，对应位置的砖块（若存在）会消失，然后其他的砖块可能因为这个消除而落下。

返回一个数组表示每次消除操作对应落下的砖块数目。

示例 1：
输入：
grid = [[1,0,0,0],[1,1,1,0]]
hits = [[1,0]]
输出: [2]
解释: 
如果我们消除(1, 0)位置的砖块, 在(1, 1) 和(1, 2) 的砖块会落下。所以我们应该返回2。

示例 2：
输入：
grid = [[1,0,0,0],[1,1,0,0]]
hits = [[1,1],[1,0]]
输出：[0,0]
解释：
当我们消除(1, 0)的砖块时，(1, 1)的砖块已经由于上一步消除而消失了。所以每次消除操作不会造成砖块落下。注意(1, 0)砖块不会记作落下的砖块。

注意:

网格的行数和列数的范围是[1, 200]。
消除的数字不会超过网格的区域。
可以保证每次的消除都不相同，并且位于网格的内部。
一个消除的位置可能没有砖块，如果这样的话，就不会有砖块落下。

class Solution {
    public:
        vector<int> parent;
        vector<int> iRank;
        vector<int> res;
        int r,c,icount;
        int dp[200][200];
        int thimax;
        int xx[4]= {-1,1,0,0};
        int yy[4]= {0,0,-1,1};
        int allone(vector<vector<int>>& grid) {

            int ic=0;
            for(int i=0; i<r; i++)
                for(int j=0; j<c; j++)
                    if(grid[i][j]==1&&dp[i][j]==0)
                    {
                        ic++;
                        grid[i][j]=0;
                    }

            return ic;
        }

        vector<int> hitBricks(vector<vector<int>>& grid, vector<vector<int>>& hits) {

            r=grid.size();
            c=grid[0].size();
            for(int kk=0; kk<hits.size(); kk++) {
                int x=hits[kk][0];
                int y=hits[kk][1];
                if(grid[x][y]==0) {
                    res.push_back(0);
                } else {
                    grid[x][y]=0;
                    memset(dp,0,sizeof(dp));//;
                    for(int i=0; i<c; i++)
                    {
                        if(grid[0][i]==1)
                            DP(0,i,grid);
                    }
                    int temp=allone(grid);
                    res.push_back(temp);
                }

            }
            return res;

        }
        void DP(int ii,int jj,vector<vector<int>>& grid)
        {
            if(dp[ii][jj]) return;
            if(dp[ii][jj]==0) dp[ii][jj]=1;
            for(int k=0; k<4; k++)
            {
                int newx=ii+xx[k];
                int newy=jj+yy[k];
                if(newx>=0&&newx<r&&newy>=0&&newy<c)
                    if(grid[newx][newy]==1)
                        DP(newx,newy,grid);
            }

        }

};

或者并查集

class Solution {
	public:
		vector<int> parent;
		vector<int> iRank;
		vector<int> res;
		int thimax;
		int xx[4]= {-1,1,0,0};
		int yy[4]= {0,0,-1,1};
		int allone(vector<vector<int>>& grid) {
			int r=grid.size();
			int c=grid[0].size();
			int ic=0;
			for(int i=1; i<r; i++)
				for(int j=0; j<c; j++)
					if(grid[i][j]==1&&iRank[root(i*c+j)]<0) {
						ic++;
						grid[i][j]=0;
					}

			return ic;
		}

		void init(vector<vector<int>>& grid) {
			int r=grid.size();
			int c=grid[0].size();
			for(int i=0; i<r; i++)
				for(int j=0; j<c; j++) {
					parent[i*c+j]=i*c+j;
					if(i==0) 
					iRank[i*c+j]=1;
					else
					iRank[i*c+j]=-1;
				}
		}

		vector<int> hitBricks(vector<vector<int>>& grid, vector<vector<int>>& hits) {

			int r=grid.size();
			int c=grid[0].size();
			parent.resize(r*c);
			iRank.resize(r*c);
			for(int kk=0; kk<hits.size(); kk++) {
				int x=hits[kk][0];
				int y=hits[kk][1];
				if(grid[x][y]==0) {
					res.push_back(0);
				} else {
					grid[x][y]=0;
					init(grid);

					for(int i=0; i<r; i++)
						for(int j=0; j<c; j++) {
							for(int k=0; k<4; k++) {
								int newx=i+xx[k];
								int newy=j+yy[k];
								if(newx>=0&&newx<r&&newy>=0&&newy<c)
									if(grid[i][j]==1&&grid[newx][newy]==1)
										uni(i*c+j,newx*c+newy);
							}

						}
					int temp=allone(grid);
					res.push_back(temp);
				}

			}
			return res;

		}

		int root(int p) {
			if(p != parent[p]) {
				parent[p] = root(parent[p]);
			}
			return parent[p];
		}
		void uni(int p, int q) {
			int proot = root(p);
			int qroot = root(q);

			if(proot == qroot) return ;

			if(iRank[proot] > iRank[qroot]) {
				parent[qroot] = proot;
			} else {
				parent[proot] = qroot;
			}

		}


};