被暴力裁员的的当天，公司还派个保安跟随，生怕搞出什么动静，真是做贼心虚啊

今天咱们聊聊一个很经典的算法问题：打砖块。

题目要求通常是这样的：给定一个包含砖块的矩阵和一个小球的发射路径，问你：小球经过这些砖块，会清除哪些砖？当然，每个砖块还有不同的耐久度，只有当小球经过且击破耐久度后，砖块才会掉落。

光说没意思，咱直接上干货：

题目拆解

1. 砖块耐久度：矩阵的每个元素代表一个砖块的耐久度，0表示这里没砖块。
2. 小球的轨迹：小球从顶部某一列下落，碰到砖块后减少砖块的耐久度。
3. 掉落判定：砖块一旦被清空耐久度，会触发其「周围砖块」的连锁掉落，类似树的连通分量问题。

解决方案：深度优先搜索（DFS） or 广度优先搜索（BFS）

用DFS来解决这道题挺方便的，每次模拟小球掉落和连锁反应就行了。

Java代码

import java.util.*;
public class BreakBricks {
    public int[][] hitBricks(int[][] grid, int[][] hits) {
        int rows = grid.length;
        int cols = grid[0].length;
        int[] directions = {-1, 0, 1, 0, -1};
        // Step 1: Mark the bricks to be hit as -1
        for (int[] hit : hits) {
            int r = hit[0];
            int c = hit[1];
            if (grid[r][c] == 1) {
                grid[r][c] = -1; // Mark as to-be-hit
            }
        }
        // Step 2: Connect stable bricks to the ceiling
        for (int col = 0; col < cols; col++) {
            dfs(grid, 0, col, directions);
        }
        // Step 3: Process the hits in reverse order
        int[] result = new int[hits.length];
        for (int i = hits.length - 1; i >= 0; i--) {
            int r = hits[i][0];
            int c = hits[i][1];
            if (grid[r][c] == -1) { // Was hit
                grid[r][c] = 1; // Restore brick
                if (isConnectedToCeiling(grid, r, c, directions)) {
                    result[i] = dfs(grid, r, c, directions) - 1;
                }
            }
        }
        return result;
    }
    private boolean isConnectedToCeiling(int[][] grid, int r, int c, int[] directions) {
        if (r == 0) return true; // Top row bricks are connected by default
        for (int i = 0; i < 4; i++) {
            int nr = r + directions[i];
            int nc = c + directions[i + 1];
            if (nr >= 0 && nc >= 0 && nr < grid.length && nc < grid[0].length && grid[nr][nc] == 2) {
                return true;
            }
        }
        return false;
    }
    private int dfs(int[][] grid, int r, int c, int[] directions) {
        if (r < 0 || c < 0 || r >= grid.length || c >= grid[0].length || grid[r][c] != 1) {
            return 0;
        }
        grid[r][c] = 2; // Mark as stable
        int bricks = 1;
        for (int i = 0; i < 4; i++) {
            bricks += dfs(grid, r + directions[i], c + directions[i + 1], directions);
        }
        return bricks;
    }
    public static void main(String[] args) {
        BreakBricks bb = new BreakBricks();
        int[][] grid = {
            {1, 0, 0, 0},
            {1, 1, 1, 0},
        };
        int[][] hits = {{1, 0}};
        System.out.println(Arrays.toString(bb.hitBricks(grid, hits))); // Output: [2]
    }
}

解题思路

1. 先标记： 模拟砖块被打掉，避免直接影响连通性。
2. 逆序操作： 因为要模拟最后一步回溯砖块恢复，所以我们从最后一个操作开始模拟。
3. DFS连通判定： 每次恢复砖块后，检查它是否能连通顶部并触发连锁掉落。

写这种题目，尤其是砖块掉落的连锁反应，和生产环境debug一模一样。你永远不知道哪块代码会「牵一发而动全身」。不过好处是，你不用担心砖块给你打工跑了。

所以，大家怎么看？是砖块掉得快，还是bug掉得更快？欢迎留言，咱们下次继续挖坑填坑！