Counting Tilings - Problem

Advanced DP DP Bitmask Hard

You are given a 3 × N grid and need to tile it completely using 2 × 1 dominoes. Each domino can be placed either horizontally (covering 2 horizontally adjacent cells) or vertically (covering 2 vertically adjacent cells).

Return the number of ways to completely tile the 3 × N grid. Since the answer can be very large, return it modulo 10⁹ + 7.

Note: The grid must be completely covered with no overlapping dominoes and no empty cells.

Input & Output

Example 1 — Basic Even Case

$ Input: n = 2

› Output: 3

💡 Note: For a 3×2 grid, there are 3 ways to tile: (1) Three horizontal dominoes stacked vertically, (2) One vertical domino on left + horizontal domino on right, (3) Horizontal domino on left + one vertical domino on right

Example 2 — Larger Even Case

$ Input: n = 4

› Output: 11

💡 Note: For a 3×4 grid, there are 11 different ways to completely tile using 2×1 dominoes

Example 3 — Odd Case (Impossible)

$ Input: n = 3

› Output: 0

💡 Note: A 3×3 grid has 9 cells total, but each domino covers 2 cells, so it's impossible to tile completely (9 is odd)

Constraints

0 ≤ n ≤ 1000
Answer fits in 32-bit integer after modulo

Visualization

Tap to expand

Asked in

G Google 12 f Facebook 8 M Microsoft 6 a Amazon 4

The key insight is using bitmask DP to represent column states efficiently. Each column can have 8 possible states (3-bit mask), and we compute transitions between states. The optimal Bitmask DP approach runs in O(N) time with O(1) space by processing columns sequentially. Time: O(N), Space: O(1).

Common Approaches

✓ Bitmask Dynamic Programming

⏱️ Time: O(N × 2³) Space: O(2³)

Use dynamic programming with bitmask to represent column states and efficiently compute transitions between valid states.

Memoized Recursion

⏱️ Time: O(N × 2³) Space: O(N × 2³)

Use memoization to store results for each column state, avoiding redundant calculations while exploring all possibilities.

Recursive Backtracking

⏱️ Time: O(3^N) Space: O(N)

Use recursive backtracking to try placing dominoes in every possible position and orientation, counting all valid complete tilings.

Bitmask Dynamic Programming — Algorithm Steps

Initialize DP array for column states
For each column, compute valid transitions
Use bitmask to represent filled cells
Return result for final column with empty state

Visualization

Tap to expand

Step-by-Step Walkthrough

State Array

Initialize DP array for 8 possible column states

Transitions

Compute valid transitions to next column

Fill Column

Use bitmask to track cell occupancy

Final Result

Return ways to reach empty state in last column

Code -

solution.c — C

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

#define MOD 1000000007

void fillColumn(int mask, int pos, int nextMask, long long ways, long long nextDp[]) {
    if (pos == 3) {
        nextDp[nextMask] = (nextDp[nextMask] + ways) % MOD;
        return;
    }
    
    if ((mask >> pos) & 1) {
        fillColumn(mask, pos + 1, nextMask, ways, nextDp);
    } else {
        // Place vertical domino
        if (pos + 1 < 3 && !((mask >> (pos + 1)) & 1)) {
            fillColumn(mask | (1 << pos) | (1 << (pos + 1)), pos + 2, nextMask, ways, nextDp);
        }
        
        // Place horizontal domino
        fillColumn(mask | (1 << pos), pos + 1, nextMask | (1 << pos), ways, nextDp);
    }
}

int solution(int n) {
    if (n % 2 == 1) {
        return 0;
    }
    
    long long dp[8] = {0};
    dp[0] = 1;
    
    for (int col = 0; col < n; col++) {
        long long nextDp[8] = {0};
        
        for (int mask = 0; mask < 8; mask++) {
            if (dp[mask] == 0) continue;
            
            fillColumn(mask, 0, 0, dp[mask], nextDp);
        }
        
        memcpy(dp, nextDp, sizeof(nextDp));
    }
    
    return (int) dp[0];
}

int main() {
    int n;
    scanf("%d", &n);
    int result = solution(n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(N × 2³)

N columns × 8 possible states per column, with constant transition time

✓ Linear Growth

Space Complexity

O(2³)

Only store current and next column states (8 states each)

✓ Linear Space

28.5K Views

Medium Frequency

~35 min Avg. Time

847 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

Counting Tilings - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bitmask Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler