JAVA程序设计：打砖块（LeetCode：803）

我们有一组包含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]。
• 消除的数字不会超过网格的区域。
• 可以保证每次的消除都不相同，并且位于网格的内部。
• 一个消除的位置可能没有砖块，如果这样的话，就不会有砖块落下。

思路：一眼看过去，我们会发现对于每次删掉一个砖块去查看其它砖块的状态不太好做到，暴力的话复杂度达到了18亿，因此我们需要倒着思考这道题，我们考虑倒着执行操作，每次往网格里填砖块，这样做的好处是，对于连通集我们可以用并查集去合并两个集合。算法实现起来并不难，首先我们将所有在第一行的砖块（不管它们是否相连）都看做同一个集合，之后处理剩下的砖块，此时我们得到了若干个集合。现在我们开始往里边加砖块，我们从最后一个要去掉的砖块开始加，若当前位置自始至终都么有砖块，则不会影响网格，若当前位置之前应该是有砖块的，我们将它周围四个砖块和它合并在一起，并且我们要使索引小的集合合并到索引大的集合，这样便于我们计数，具体的计数方法可以看代码。

class Solution {
	
	class node{
		
		int[] f;
		int[] rank;
		int[] size;
		
		public node(int n) {
			f=new int[n];
			for(int i=0;i<n;i++)
				f[i]=i;
			rank=new int[n];
			size=new int[n];
			Arrays.fill(size, 1);
		}
		
		public int find(int x) {
			if(f[x]==x)
				return x;
			return f[x]=find(f[x]);
		}
		
		public void union(int x,int y) {
			
			int t1=find(x),t2=find(y);
			
			if(t1==t2) return;
			
			if(rank[t1]<rank[t2]) {
				int tmp=t1;
				t1=t2;
				t2=tmp;
			}
			
			f[t2]=t1;
			size[t1]+=size[t2];
		}
		
		public int Size(int x) {
			return size[find(x)];	
		}
		
		public int top() {
			return Size(size.length-1)-1;
		}
	}
	
    public int[] hitBricks(int[][] grid, int[][] hits) {
    	
    	int r=grid.length;
    	int c=grid[0].length;
    	int[] dx= {1,-1,0,0};
    	int[] dy= {0,0,1,-1};
    	int[][] A=new int[r][c];
    	
    	for(int i=0;i<r;i++)
    		A[i]=grid[i].clone();
    	for(int i=0;i<hits.length;i++)
    		A[hits[i][0]][hits[i][1]]=0;
    	
    	node mynode=new node(r*c+1);
    	for(int i=0;i<r;i++)
    		for(int j=0;j<c;j++) {
    			if(A[i][j]==1) {
    				int num=i*c+j;
    				if(i==0)
    					mynode.union(num, r*c);
    				if(i>0 && A[i-1][j]==1)
    					mynode.union(num, (i-1)*c+j);
    				if(j>0 && A[i][j-1]==1)
    					mynode.union(num, i*c+j-1);
    			}
    		}
    	
    	int len=hits.length;
    	int[] ans=new int[len--];
    	
    	while(len>=0) {
    		int x=hits[len][0];
    		int y=hits[len][1];
    		int sz=mynode.top();
    		if(grid[x][y]==0)
    			len--;
    		else {
    			int num=x*c+y;
    			for(int i=0;i<4;i++) {
    				int xx=x+dx[i];
    				int yy=y+dy[i];
    				if(xx>=0 && xx<r && yy>=0 && yy<c && A[xx][yy]==1)
    					mynode.union(num, xx*c+yy);
    			}
    			if(x==0)
    				mynode.union(num, r*c);
    			A[x][y]=1;
    			ans[len--]=Math.max(0, mynode.top()-sz-1);
    		}
    	}
    	
    	return ans;
    }
}