Domino and Tromino Tiling

Domino and Tromino Tiling - Problem

Dynamic Programming Medium

You have two types of tiles:

A 2 × 1 domino shape
A tromino shape (L-shaped)

You may rotate these shapes. Given an integer n, return the number of ways to tile a 2 × n board. Since the answer may be very large, return it modulo 10⁹ + 7.

In a tiling, every square must be covered by a tile. Two tilings are different if and only if there are two 4-directionally adjacent cells on the board such that exactly one of the tilings has both squares occupied by a tile.

Input & Output

Example 1 — Basic Case

$ Input: n = 3

› Output: 5

💡 Note: There are 5 ways to tile a 2×3 board: (1) three vertical dominos, (2) one vertical + two horizontal, (3) two horizontal + one vertical, (4) two trominos, (5) different tromino arrangement

Example 2 — Minimum Case

$ Input: n = 1

› Output: 1

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

Example 3 — Small Even

$ Input: n = 2

› Output: 2

💡 Note: Two ways to tile a 2×2 board: (1) two vertical dominos side by side, (2) two horizontal dominos stacked

Constraints

1 ≤ n ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to use dynamic programming with three states: fully covered board, board with top cell extending, and board with bottom cell extending. The optimal approach uses bottom-up DP with state transitions. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force Recursion

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

For each position, try placing all possible tile configurations and recursively solve for the remaining board. This explores every possible combination without storing results.

Dynamic Programming (Bottom-Up)

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

Use three states to track different board configurations: fully covered, top cell hanging, bottom cell hanging. Build up the solution column by column using recurrence relations.

Recursion with Memoization

⏱️ Time: O(n) Space: O(n)

Same recursive approach as brute force, but store results of subproblems in a cache. When we encounter the same state again, return the cached result instead of recalculating.

Brute Force Recursion — Algorithm Steps

Try placing vertical domino at current position
Try placing horizontal dominos at current position
Try placing trominos in all orientations
Recursively solve for remaining board

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with empty 2×n board

Try All Tiles

At each position, try vertical domino, horizontal dominos, and trominos

Recurse

For each placement, recursively solve remaining board

Code -

solution.c — C

#include <stdio.h>

const int MOD = 1000000007;

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

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

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

Each position has roughly 3 choices (vertical domino, horizontal pair, tromino), leading to exponential branches

✓ Linear Growth

Space Complexity

O(n)

Recursion depth is at most n levels deep

✓ Linear Space

23.4K Views

Medium Frequency

~25 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

Brute Force Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler