Java实现 LeetCode 803 打砖块 （DFS）

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

class Solution {
     int count=0;
    public int[] hitBricks(int[][] grid, int[][] hits) {
        int[] ret = new int[hits.length];
        // 先把砖块打掉
        for(int[] hit : hits){
            if(grid[hit[0]][hit[1]] == 1)
                grid[hit[0]][hit[1]] = -1;
        }
        // 贴上最顶层的砖块和与最顶层连接的砖块
        for(int k = 0; k < grid[0].length; ++k){
            if(grid[0][k] == 1){
                isWayToTop(grid, 0, k);
            }
        }
        for(int i = hits.length - 1; i >= 0; --i){
            count = 0;
            //在删掉之前的情况下，如果能保存的话，就恢复此砖块，因为后面可能有和这个砖块有联系的
            //可能导致前面的砖块先over，导致后面的掉了，我们可以把他做恢复模拟
            if(canHit(grid, hits[i][0], hits[i][1]) && grid[hits[i][0]][hits[i][1]] == -1){
                isWayToTop(grid, hits[i][0], hits[i][1]);
                ret[i] = count - 1;
            }

        }
        return ret;
    }
    public void isWayToTop(int[][] grid, int i, int j){
        grid[i][j] = 2;
        ++ count;
        if (i + 1 < grid.length  && grid[i + 1][j] == 1) {
            isWayToTop(grid,  i + 1, j);
        }
        if (j + 1 < grid[0].length &&  grid[i][j + 1] == 1) {
            isWayToTop(grid,  i, j + 1);
        }
        if (i-1>=0&& grid[i - 1][j] == 1) {
            isWayToTop(grid, i - 1, j);
        }
        if (j - 1 >= 0 &&  grid[i][j - 1] == 1) {
            isWayToTop(grid, i, j - 1);
        }
    }
    public boolean canHit(int [][] grid,int i,int j){
        if(i == 0)
            return true;
        if (i + 1 < grid.length  && grid[i + 1][j] == 2) {
            return true;
        }
        if (j + 1 < grid[0].length &&  grid[i][j + 1] == 2) {
            return true;
        }
        if (i - 1 >= 0 && grid[i - 1][j] == 2) {
            return true;
        }
        if (j - 1 >= 0 &&  grid[i][j - 1] == 2) {
            return true;
        }
        if(grid[i][j] == -1)
            grid[i][j] = 1;
        return false;
    }
}