Domino and Tromino Tiling - Practice Coding Problems

Domino and Tromino Tiling - Problem

Dynamic Programming Medium

Imagine you're a tile artist working on a 2×n board and you have two types of beautiful tiles at your disposal:

Domino tiles: 2×1 rectangular pieces that can be placed horizontally or vertically
Tromino tiles: L-shaped pieces made of 3 squares that can be rotated in 4 different orientations

Your challenge is to find the total number of ways to completely tile a 2×n board using these pieces. Every single square on the board must be covered, and no tiles can overlap or extend beyond the board boundaries.

Goal: Given an integer n, return the number of distinct ways to tile the 2×n board.

Note: Since the answer can be astronomically large, return it modulo 10^9 + 7. Two tilings are considered different if there exists at least one position where one tiling has a tile occupying a square that the other tiling doesn't.

Input & Output

example_1.py — Small Board (n=3)

$ Input: n = 3

› Output: 5

💡 Note: For a 2×3 board, there are 5 ways: 3 vertical dominoes, 1 horizontal pair + 1 vertical, and 2 tromino-based configurations.

example_2.py — Minimal Case (n=1)

$ Input: n = 1

› Output: 1

💡 Note: Only one way to tile a 2×1 board: place a single vertical domino.

example_3.py — Medium Board (n=4)

$ Input: n = 4

› Output: 11

💡 Note: A 2×4 board can be tiled in 11 different ways using various combinations of dominoes and trominos.

Constraints

1 ≤ n ≤ 1000
Answer must be returned modulo 10⁹ + 7
Board dimensions are always 2 × n

Visualization

Tap to expand

Understanding the Visualization

Identify Tile Types

Recognize the available domino and tromino pieces and their orientations

Define Column States

Each column can be in a 'complete' or 'partial' state based on previous tiles

Calculate Transitions

Determine how each state can lead to valid next states

Build Solution

Use dynamic programming to count total valid tilings

Key Takeaway

🎯 Key Insight: Instead of trying all possible tile placements, we track column states and use mathematical transitions to build the solution efficiently in linear time.

Asked in

G Google 42 ⊞ Microsoft 38 a Amazon 29 f Meta 25

The optimal solution uses dynamic programming with state tracking to achieve O(n) time complexity. By recognizing that we only need to track whether columns are completely filled or partially filled, we can build the solution incrementally using mathematical state transitions rather than exploring all possible tile placements.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with State Tracking (Optimal)	O(n)	O(1)	Track board states and build solution incrementally using memoization
Brute Force (Exponential Recursion)	O(3^n)	O(n)	Try all possible ways to place tiles recursively without memoization

Dynamic Programming with State Tracking (Optimal) — Algorithm Steps

Define possible states for each column (empty, partially filled, etc.)
Initialize base cases for the first few columns
For each column, calculate possible transitions from previous states
Track the number of ways to reach each state
Return the final state representing a completely filled board

Visualization

Tap to expand

Step-by-Step Walkthrough

Define States

Identify possible column states: complete, partial top, partial bottom

Base Cases

Initialize first few columns with known values

State Transitions

Calculate how each state can transition to next column

Build Solution

Accumulate total ways for each column

Code -

solution.c — C

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

#define MOD 1000000007

int numTilings(int n) {
    if (n == 1) return 1;
    if (n == 2) return 2;
    
    long long dp[n + 1];
    long long partial[n + 1];
    
    for (int i = 0; i <= n; i++) {
        dp[i] = 0;
        partial[i] = 0;
    }
    
    dp[0] = 1;
    dp[1] = 1;
    partial[1] = 1;
    
    for (int i = 2; i <= n; i++) {
        dp[i] = (dp[i-1] + dp[i-2] + 2 * partial[i-1]) % MOD;
        partial[i] = (dp[i-2] + partial[i-1]) % MOD;
    }
    
    return (int)dp[n];
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

We process each column once, with constant time state transitions

✓ Linear Growth

Space Complexity

O(1)

We only need to store a few state values, not the entire board history

✓ Linear Space

42.0K Views

Medium Frequency

~18 min Avg. Time

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

Dynamic Programming with State Tracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler