Bricks Falling When Hit - Practice Coding Problems

Bricks Falling When Hit - Problem

Bricks Falling When Hit is a challenging grid simulation problem that models a brick wall's structural integrity. You have an m × n binary grid where 1 represents a brick and 0 represents empty space.

A brick is stable if:
• It's directly connected to the top row (foundation)
• At least one of its 4 adjacent neighbors is stable

You're given a sequence of hits array where each hit removes a brick at position [row, col]. When a brick is removed, other bricks may become unstable and fall immediately (disappearing from the grid).

Goal: Return an array where each element represents the number of bricks that fall after each hit.

Input & Output

example_1.py — Python

$ Input: grid = [[1,0,0,0],[1,1,1,0],[1,0,1,0],[1,1,1,1]], hits = [[1,0]]

› Output: [2]

💡 Note: After hitting brick at [1,0], the brick at [2,2] becomes disconnected from the top and falls, causing [3,2] to also fall. Total: 2 bricks fall.

example_2.py — Python

$ Input: grid = [[1,0,0,0],[1,1,0,0]], hits = [[1,1],[1,0]]

› Output: [0,0]

💡 Note: First hit [1,1] removes a brick but no others fall (0). Second hit [1,0] removes last brick in bottom row, but it was already disconnected (0).

example_3.py — Python

$ Input: grid = [[1,1,1],[0,1,0],[0,0,0]], hits = [[0,2],[2,0],[0,1],[0,0]]

› Output: [0,0,1,0]

💡 Note: Edge case with hits on empty spaces and sequential disconnections. Only the third hit causes 1 brick to fall.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 200
grid[i][j] is 0 or 1
1 ≤ hits.length ≤ 4 × 10⁴
hits[i].length == 2
0 ≤ hits[i][0] < m
0 ≤ hits[i][1] < n
All hits are unique

Asked in

The optimal solution uses Union-Find with reverse engineering. Instead of simulating brick removals (expensive), we apply all hits first, then add bricks back in reverse order. Each time we add a brick back, we use Union-Find to efficiently count how many previously disconnected bricks become stable by connecting to the roof. This achieves O(h × α(n)) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find (Reverse Engineering - Optimal)	O(h × α(n))	O(m × n)	Work backwards: remove all hits first, then add bricks back to count newly stable ones
Brute Force (DFS After Each Hit)	O(h × m × n)	O(m × n)	After each hit, run DFS to find all stable bricks and count fallen ones

Union-Find (Reverse Engineering - Optimal) — Algorithm Steps

Create a copy of grid and apply all hits to get final state
Initialize Union-Find with a virtual 'roof' node connected to top row
Add back bricks in reverse order of hits
For each brick added, check how many new bricks become connected to roof
The difference in roof component size is the answer for that hit

Visualization

Tap to expand

Step 1: Apply all hits firstStep 2: Build Union-Find with remaining bricksStep 3: Add bricks back in reverse orderStep 4: Count newly connected bricks = answer🟦 Connected to roof🟨 Isolated component🟥 Brick being added💡 Key Insight: Reverse EngineeringInstead of removing bricks and checking instability,we add bricks back and count newly stable ones!Time: O(h × α(n)) - Nearly Optimal!

Step-by-Step Walkthrough

Apply All Hits

Start with all hits applied to grid

Build Union-Find

Connect remaining bricks using Union-Find

Add Brick Back

Add hit brick back in reverse order

Count New Connections

Count how many bricks become connected to roof

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int* parent;
    int* size;
    int n;
} UnionFind;

UnionFind* createUF(int n) {
    UnionFind* uf = malloc(sizeof(UnionFind));
    uf->parent = malloc(n * sizeof(int));
    uf->size = malloc(n * sizeof(int));
    uf->n = n;
    for (int i = 0; i < n; i++) {
        uf->parent[i] = i;
        uf->size[i] = 1;
    }
    return uf;
}

int find(UnionFind* uf, int x) {
    if (uf->parent[x] != x) {
        uf->parent[x] = find(uf, uf->parent[x]);
    }
    return uf->parent[x];
}

void unionSets(UnionFind* uf, int x, int y) {
    int px = find(uf, x), py = find(uf, y);
    if (px == py) return;
    if (uf->size[px] < uf->size[py]) {
        int temp = px; px = py; py = temp;
    }
    uf->parent[py] = px;
    uf->size[px] += uf->size[py];
}

int getSize(UnionFind* uf, int x) {
    return uf->size[find(uf, x)];
}

int* hitBricks(int** grid, int gridSize, int* gridColSize, int** hits, int hitsSize, int* hitsColSize, int* returnSize) {
    int m = gridSize, n = gridColSize[0];
    *returnSize = hitsSize;
    
    // Apply all hits
    for (int i = 0; i < hitsSize; i++) {
        grid[hits[i][0]][hits[i][1]] = 0;
    }
    
    UnionFind* uf = createUF(m * n + 1);
    int roof = m * n;
    
    // Build initial structure
    for (int r = 0; r < m; r++) {
        for (int c = 0; c < n; c++) {
            if (grid[r][c] == 1) {
                int idx = r * n + c;
                if (r == 0) unionSets(uf, idx, roof);
                int dirs[4][2] = {{0,1}, {0,-1}, {1,0}, {-1,0}};
                for (int d = 0; d < 4; d++) {
                    int nr = r + dirs[d][0], nc = c + dirs[d][1];
                    if (nr >= 0 && nr < m && nc >= 0 && nc < n && grid[nr][nc] == 1) {
                        unionSets(uf, idx, nr * n + nc);
                    }
                }
            }
        }
    }
    
    int* result = malloc(hitsSize * sizeof(int));
    
    // Process hits in reverse
    for (int i = hitsSize - 1; i >= 0; i--) {
        int r = hits[i][0], c = hits[i][1];
        int prevSize = getSize(uf, roof);
        
        grid[r][c] = 1;
        int idx = r * n + c;
        
        if (r == 0) unionSets(uf, idx, roof);
        
        int dirs[4][2] = {{0,1}, {0,-1}, {1,0}, {-1,0}};
        for (int d = 0; d < 4; d++) {
            int nr = r + dirs[d][0], nc = c + dirs[d][1];
            if (nr >= 0 && nr < m && nc >= 0 && nc < n && grid[nr][nc] == 1) {
                unionSets(uf, idx, nr * n + nc);
            }
        }
        
        int newSize = getSize(uf, roof);
        result[i] = (newSize - prevSize - 1 > 0) ? newSize - prevSize - 1 : 0;
    }
    
    free(uf->parent);
    free(uf->size);
    free(uf);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(h × α(n))

h hits, each with Union-Find operations that have α(n) amortized complexity

✓ Linear Growth

Space Complexity

O(m × n)

Union-Find parent array and grid copy

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen