Brick Wall

Brick Wall - Problem

There is a rectangular brick wall in front of you with n rows of bricks. The i-th row has some number of bricks each of the same height (i.e., one unit) but they can be of different widths. The total width of each row is the same.

Draw a vertical line from the top to the bottom and cross the least bricks. If your line goes through the edge of a brick, then the brick is not considered as crossed. You cannot draw a line just along one of the two vertical edges of the wall, in which case the line will obviously cross no bricks.

Given the 2D array wall that contains the information about the wall, return the minimum number of crossed bricks after drawing such a vertical line.

Input & Output

Example 1 — Standard Wall

$ Input: wall = [[1,2,2,1],[3,1,2],[1,3,2],[2,4],[3,1,1,1],[1,1,2,2]]

› Output: 2

💡 Note: The wall has 6 rows. Drawing a vertical line at position 4 passes through edges of 4 rows, so it crosses only 2 bricks (6-4=2).

Example 2 — Single Column

$ Input: wall = [[1],[1],[1]]

› Output: 3

💡 Note: All rows have only one brick each, so any vertical line must cross all 3 bricks. No edges exist except at boundaries.

Example 3 — Perfect Alignment

$ Input: wall = [[2,1],[2,1],[2,1]]

› Output: 0

💡 Note: All rows have an edge at position 2, so we can draw a line there that crosses 0 bricks.

Constraints

n == wall.length
1 ≤ n ≤ 10⁴
1 ≤ wall[i].length ≤ 10⁴
1 ≤ sum(wall[i].length) ≤ 2 × 10⁴
1 ≤ wall[i][j] ≤ 2³¹ - 1
For each row i, sum(wall[i]) is the same.

Visualization

Tap to expand

Asked in

f Facebook 35 G Google 28 a Amazon 22 M Microsoft 18

The key insight is that to minimize crossed bricks, we should find the vertical position where the most brick edges align. Using a hash map to count edge frequencies gives us O(n×m) time complexity. The answer is total_rows - max_edge_frequency.

Common Approaches

✓ Brute Force - Try Every Position

⏱️ Time: O(n × w) Space: O(1)

For each possible vertical position from 1 to total_width-1, count how many bricks are crossed by a vertical line at that position. Return the minimum count.

Hash Map - Count Edge Positions

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

For each row, calculate cumulative positions of brick edges and count their frequency. The position with most edges allows the line to pass through without crossing bricks.

Brute Force - Try Every Position — Algorithm Steps

Find total width of wall
For each position 1 to width-1, count bricks crossed
Return minimum count

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Position 1

Count bricks crossed at position 1

Try Position 2

Count bricks crossed at position 2

Find Minimum

Return the position with least crossed bricks

Code -

solution.c — C

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

int solution(int** wall, int wallSize, int* wallColSize) {
    if (wallSize == 0 || wallColSize[0] == 0) return 0;
    
    int totalWidth = 0;
    for (int i = 0; i < wallColSize[0]; i++) {
        totalWidth += wall[0][i];
    }
    
    int minCrossed = wallSize;
    
    for (int pos = 1; pos < totalWidth; pos++) {
        int crossed = 0;
        for (int i = 0; i < wallSize; i++) {
            int currentPos = 0;
            int brickCrossed = 0;
            for (int j = 0; j < wallColSize[i]; j++) {
                if (currentPos < pos && pos < currentPos + wall[i][j]) {
                    brickCrossed = 1;
                    break;
                }
                currentPos += wall[i][j];
                if (currentPos >= pos) break;
            }
            if (brickCrossed) crossed++;
        }
        if (crossed < minCrossed) minCrossed = crossed;
    }
    
    return minCrossed;
}

int main() {
    // Simple parsing for demo - in practice would need full JSON parser
    int wall1[] = {1, 2, 2, 1};
    int wall2[] = {3, 1, 2};
    int wall3[] = {1, 3, 2};
    int wall4[] = {2, 4};
    int wall5[] = {3, 1, 1, 1};
    int wall6[] = {1, 1, 2, 2};
    
    int* wall[] = {wall1, wall2, wall3, wall4, wall5, wall6};
    int wallColSize[] = {4, 3, 3, 2, 4, 4};
    
    printf("%d\n", solution(wall, 6, wallColSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × w)

For each of w positions, we check n rows to count crossed bricks

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track position and count

✓ Linear Space

87.0K Views

Medium Frequency

~15 min Avg. Time

2.2K 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

Brute Force - Try Every Position — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler