803. Bricks Falling When Hit

最新推荐文章于 2021-01-16 21:45:09 发布

BigFatSheep

最新推荐文章于 2021-01-16 21:45:09 发布

阅读量309

点赞数

CC 4.0 BY-SA版权

分类专栏： Leetcode Hard

本文链接：https://blog.youkuaiyun.com/BigFatSheep/article/details/83729912

Leetcode 同时被 2 个专栏收录

385 篇文章

订阅专栏

Hard

51 篇文章

订阅专栏

本文介绍了一种模拟砖块在网格中掉落的算法。通过在一系列hit操作后，计算每一步hit导致的砖块掉落数量。算法首先移除所有hit位置的砖块，然后标记与顶部相连的所有砖块，再逐步恢复hit位置并计算新增掉落的砖块数量。

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

Description

We have a grid of 1s and 0s; the 1s in a cell represent bricks. A brick will not drop if and only if it is directly connected to the top of the grid, or at least one of its (4-way) adjacent bricks will not drop.

We will do some erasures sequentially. Each time we want to do the erasure at the location (i, j), the brick (if it exists) on that location will disappear, and then some other bricks may drop because of that erasure.

Return an array representing the number of bricks that will drop after each erasure in sequence.

Example 1:
Input:
grid = [[1,0,0,0],[1,1,1,0]]
hits = [[1,0]]
Output: [2]
Explanation:
If we erase the brick at (1, 0), the brick at (1, 1) and (1, 2) will drop. So we should return 2.
Example 2:
Input:
grid = [[1,0,0,0],[1,1,0,0]]
hits = [[1,1],[1,0]]
Output: [0,0]
Explanation:
When we erase the brick at (1, 0), the brick at (1, 1) has already disappeared due to the last move. So each erasure will cause no bricks dropping. Note that the erased brick (1, 0) will not be counted as a dropped brick.

Note:

The number of rows and columns in the grid will be in the range [1, 200].
The number of erasures will not exceed the area of the grid.
It is guaranteed that each erasure will be different from any other erasure, and located inside the grid.
An erasure may refer to a location with no brick - if it does, no bricks drop.

Problem URL

Solution

给一个二维数组，1表示砖，只要与顶部联通，砖就不会掉落，在一系列的hit之后，找到所有掉下来的砖。

Code

class Solution {
    private static final int TOP = 2;
    private static final int BRICK = 1;
    private static final int EMPTY = 0;
    private static final int[][] DIRS = {{1, 0}, {-1, 0}, {0, 1},{0, -1}};
    public int[] hitBricks(int[][] grid, int[][] hits) {
        int[] res = new int[hits.length];
        //remove all hits and then add them back
        for (int[] hit : hits){
            grid[hit[0]][hit[1]]--;
        }
        
        //assign 2 to all grids connected to top;
        for (int i = 0; i < grid[0].length; i++){
            dfs(0, i, grid);
        }
        
        //add back removed hitted bricks
        for (int i = hits.length - 1; i >= 0; i--){
            int x = hits[i][0], y = hits[i][1];
            grid[x][y]++;
            if (grid[x][y] == BRICK && isConnected(x, y, grid)){
                res[i] = dfs(x, y, grid) - 1;
            }
        }
        return res;
    }
    
    private int dfs(int i, int j, int[][] grid){
        if (i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] != BRICK){
            return 0;
        }
        grid[i][j] = 2;
        return dfs(i + 1, j, grid) +
        dfs(i - 1, j, grid) +
        dfs(i, j + 1, grid) +
        dfs(i, j - 1, grid) + 1;
    }
    
    private boolean isConnected(int i, int j, int[][] grid){
        if (i == 0){
            return true;
        }
        for (int[] dir : DIRS){
            int x = i + dir[0], y = j + dir[1];
            if (x >= 0 && x < grid.length && y >= 0 && y < grid[0].length && grid[x][y] == TOP){
                return true;
            }
        }
        return false;
    }
}