Number of Ways to Build Sturdy Brick Wall

Number of Ways to Build Sturdy Brick Wall - Problem

You're tasked with building a sturdy brick wall with specific dimensions and constraints. Given a wall of height rows and width units, you must construct it using bricks from an array where each brick has height 1 and width bricks[i].

Key Requirements:

Each row must be exactly width units long
You have an infinite supply of each brick type
Bricks cannot be rotated
Sturdy constraint: Adjacent rows cannot have joints at the same position (except at the wall ends)

Return the number of ways to build such a wall, modulo 10⁹ + 7.

Example: With height=2, width=3, bricks=[1,2], you could have row 1 as [2,1] and row 2 as [1,2], since their internal joints don't align.

Input & Output

example_1.py — Basic Case

$ Input: height = 2, width = 3, bricks = [1, 2]

› Output: 2

💡 Note: Two valid ways: Row1=[2,1] Row2=[1,2], and Row1=[1,2] Row2=[2,1]. In both cases, internal joints don't align.

example_2.py — Single Row

$ Input: height = 1, width = 4, bricks = [1, 2]

› Output: 5

💡 Note: One row can be filled as: [1,1,1,1], [1,1,2], [1,2,1], [2,1,1], [2,2]. All are valid since there's no adjacent row to conflict with.

example_3.py — No Valid Arrangement

$ Input: height = 2, width = 3, bricks = [2]

› Output: 0

💡 Note: Width 3 cannot be filled using only bricks of size 2 (3 is odd, but we need even sum). No valid arrangements exist.

Visualization

Tap to expand

Understanding the Visualization

Generate Row Patterns

Find all possible ways to fill one row with given bricks, recording internal joint positions

Pattern Compatibility

Create a matrix showing which row patterns can be placed adjacent to each other

Dynamic Programming

Use DP to count ways to build the wall, ensuring each row uses only compatible patterns

Sum All Possibilities

The final answer is the sum of all valid ways to complete the wall

Key Takeaway

🎯 Key Insight: The problem becomes manageable when we realize we only need to track joint positions (using bitmasks) rather than actual brick arrangements, and use dynamic programming to efficiently count valid wall configurations.

Time & Space Complexity

Time Complexity

⏱️

O(P^2 * H)

Where P is the number of unique row patterns and H is height. We check compatibility between all pattern pairs once, then DP through H rows

✓ Linear Growth

Space Complexity

O(P * H)

DP table storing ways to reach each pattern at each row level

✓ Linear Space

Constraints

1 ≤ height ≤ 200
1 ≤ width ≤ 200
1 ≤ bricks.length ≤ 10
1 ≤ bricks[i] ≤ width
All bricks[i] are unique
Answer fits in 32-bit integer after modulo 10⁹ + 7

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

This problem requires dynamic programming with bitmask optimization. The key insight is to represent joint positions as bitmasks and use DP to count valid wall configurations. First generate all possible row patterns, then build a compatibility matrix to check which patterns can be adjacent (no overlapping internal joints). Finally, use DP where dp[row][pattern] represents the number of ways to reach a specific pattern at each row level. The optimal solution runs in O(P² × H) time where P is the number of unique row patterns.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Combinations)	O(k^height)	O(height * width)	Generate all possible row arrangements and check validity
Dynamic Programming with Memoization (Optimal)	O(P^2 * H)	O(P * H)	Use bitmasks to represent joint patterns and DP to count valid combinations

Brute Force (Generate All Combinations) — Algorithm Steps

Generate all possible ways to fill a single row of width W using given bricks
For each row arrangement, calculate the positions of internal joints
Use recursion to build the wall row by row
For each new row, check if its joints conflict with the previous row
Count all valid complete walls

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Row Patterns

Find all ways to fill width=4 with bricks [1,2]

Check Joint Conflicts

Verify adjacent rows don't share internal joint positions

Build Wall Recursively

Try each valid pattern for the next row

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_PATTERNS 10000
#define MAX_JOINTS 100

typedef struct {
    int joints[MAX_JOINTS];
    int count;
} Pattern;

Pattern patterns[MAX_PATTERNS];
int patternCount = 0;

void generateRowPatterns(int remaining, int* current, int currentSize, int* bricks, int brickCount) {
    if (remaining == 0) {
        for (int i = 0; i < currentSize - 1; i++) {
            patterns[patternCount].joints[i] = current[i];
        }
        patterns[patternCount].count = currentSize - 1;
        patternCount++;
        return;
    }
    
    for (int i = 0; i < brickCount; i++) {
        if (bricks[i] <= remaining) {
            current[currentSize] = current[currentSize - 1] + bricks[i];
            generateRowPatterns(remaining - bricks[i], current, currentSize + 1, bricks, brickCount);
        }
    }
}

int hasConflict(Pattern* p1, Pattern* p2) {
    for (int i = 0; i < p1->count; i++) {
        for (int j = 0; j < p2->count; j++) {
            if (p1->joints[i] == p2->joints[j]) {
                return 1;
            }
        }
    }
    return 0;
}

long long buildWall(int row, int prevPattern, int height) {
    if (row == height) return 1;
    
    long long count = 0;
    for (int i = 0; i < patternCount; i++) {
        if (prevPattern == -1 || !hasConflict(&patterns[prevPattern], &patterns[i])) {
            count = (count + buildWall(row + 1, i, height)) % MOD;
        }
    }
    return count;
}

int main() {
    int height, width;
    scanf("%d %d", &height, &width);
    
    int bricks[20], brickCount = 0;
    char line[1000];
    fgets(line, sizeof(line), stdin); // consume newline
    fgets(line, sizeof(line), stdin);
    
    char* token = strtok(line, " ");
    while (token != NULL) {
        bricks[brickCount++] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    int initial[] = {0};
    generateRowPatterns(width, initial, 1, bricks, brickCount);
    
    printf("%lld\n", buildWall(0, -1, height));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^height)

Where k is the number of ways to fill one row. In worst case, this can be exponential

✓ Linear Growth

Space Complexity

O(height * width)

Recursion stack depth times the space needed to store row configurations

✓ Linear Space

Constraints

1 ≤ height ≤ 200
1 ≤ width ≤ 200
1 ≤ bricks.length ≤ 10
1 ≤ bricks[i] ≤ width
All bricks[i] are unique
Answer fits in 32-bit integer after modulo 10⁹ + 7

38.5K Views

Medium Frequency

~25 min Avg. Time

1.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Generate All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler