Bricks Falling When Hit

Bricks Falling When Hit - Problem

You are given an m x n binary grid, where each 1 represents a brick and 0 represents an empty space. A brick is stable if:

It is directly connected to the top of the grid, or
At least one other brick in its four adjacent cells is stable

You are also given an array hits, which is a sequence of erasures we want to apply. Each time we want to erase the brick at location hits[i] = (row_i, col_i). The brick on that location (if it exists) will disappear. Some other bricks may no longer be stable because of that erasure and will fall.

Once a brick falls, it is immediately erased from the grid (i.e., it does not land on other stable bricks).

Return an array result, where each result[i] is the number of bricks that will fall after the ith erasure is applied.

Note: An erasure may refer to a location with no brick, and if it does, no bricks drop.

Input & Output

Example 1 — Basic Hit

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

› Output: [2]

💡 Note: Initially all 4 bricks are stable. After hitting (1,0), only the top-left brick remains stable, so 2 bricks fall (the ones at (1,1) and (1,2)).

Example 2 — Multiple Hits

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

› Output: [0,1]

💡 Note: First hit at (1,1) removes an isolated brick, no others fall. Second hit at (1,0) disconnects the remaining bottom brick from the top, so 1 brick falls.

Example 3 — Empty Hit

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

› Output: [0]

💡 Note: Hitting position (1,3) which has no brick, so no bricks 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 ≤ x_i ≤ m - 1
0 ≤ y_i ≤ n - 1

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 a Amazon 22

The key insight is to work backwards using Union-Find. Instead of removing bricks and checking connectivity, we start from the final state and add bricks back, efficiently tracking which bricks become connected to the ceiling. Best approach is Reverse Union-Find. Time: O(m × n × α(m × n)), Space: O(m × n)

Common Approaches

✓ Reverse Union-Find

⏱️ Time: O(m × n × α(m × n)) Space: O(m × n)

Apply all hits first, then work backwards adding bricks back. Use Union-Find to efficiently track which bricks are connected to the ceiling (top row). This avoids repeated DFS traversals.

Simulation with DFS

⏱️ Time: O(k × m × n) Space: O(m × n)

For each hit, remove the brick, then use DFS from the top row to mark all stable bricks. Count how many bricks became unstable compared to before the hit.

Reverse Union-Find — Algorithm Steps

Apply all hits to create final state
Work backwards, adding each brick back
Use Union-Find to track ceiling connectivity
Count newly connected bricks for each reverse operation

Visualization

Tap to expand

Step-by-Step Walkthrough

Apply All Hits

Start with final state after all hits

Union-Find Setup

Build connectivity with virtual ceiling node

Reverse Process

Add bricks back and count newly connected ones

Code -

solution.c — C

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

char** solution(int* target, int targetSize, int n, int* returnSize) {
    char** operations = malloc(2 * n * sizeof(char*));
    int opCount = 0;
    int targetIndex = 0;
    int current = 1;
    
    while (targetIndex < targetSize && current <= n) {
        operations[opCount] = malloc(5 * sizeof(char));
        strcpy(operations[opCount], "Push");
        opCount++;
        
        if (current == target[targetIndex]) {
            targetIndex++;
        } else {
            operations[opCount] = malloc(4 * sizeof(char));
            strcpy(operations[opCount], "Pop");
            opCount++;
        }
        
        current++;
    }
    
    *returnSize = opCount;
    return operations;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse target array
    int target[100];
    int targetSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        target[targetSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int n;
    scanf("%d", &n);
    
    int returnSize;
    char** result = solution(target, targetSize, n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("\"%s\"", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n × α(m × n))

Union-Find operations with inverse Ackermann function amortized cost

✓ Linear Growth

Space Complexity

O(m × n)

Union-Find parent and size arrays plus grid copy

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~45 min Avg. Time

892 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Reverse Union-Find — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler