Number of Ways to Paint N × 3 Grid - Practice Coding Problems

Number of Ways to Paint N × 3 Grid - Problem

Dynamic Programming Hard

Imagine you're tasked with creating a stunning n × 3 grid art piece using exactly three colors: Red, Yellow, and Green. The challenge? No two adjacent cells can share the same color!

Each cell in your grid must be painted with exactly one color, and cells that share a horizontal or vertical edge cannot have the same color. This creates a beautiful constraint that makes the problem both challenging and elegant.

Your mission: Given n (the number of rows), calculate how many different ways you can paint this grid while following the adjacency rule.

Note: Since the answer can grow exponentially large, return the result modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Case

$ Input: n = 1

› Output: 12

💡 Note: For a 1×3 grid, we have 6 ABA patterns (RGR, RYR, GRG, GYG, YRY, YGY) and 6 ABC patterns (RGY, RYG, GRY, GYR, YRG, YGR), totaling 12 ways.

example_2.py — Small Grid

$ Input: n = 2

› Output: 54

💡 Note: For a 2×3 grid, we apply transition rules: from 6 ABA + 6 ABC in first row, we get (6×3 + 6×2) + (6×2 + 6×2) = 30 + 24 = 54 total ways.

example_3.py — Larger Grid

$ Input: n = 3

› Output: 246

💡 Note: For a 3×3 grid, continuing the pattern: from 30 ABA + 24 ABC in second row, we get (30×3 + 24×2) + (30×2 + 24×2) = 138 + 108 = 246 ways.

Constraints

1 ≤ n ≤ 5000
Grid is always n × 3 (exactly 3 columns)
Must use exactly 3 colors: Red, Yellow, Green
Answer must be computed modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Initial State

Start with 6 ABA patterns and 6 ABC patterns for first row

Apply Transitions

Use rules: ABA→ABA(3), ABA→ABC(2), ABC→ABA(2), ABC→ABC(2)

Continue Pattern

Repeat transitions for each additional row until we reach n rows

Key Takeaway

🎯 Key Insight: By recognizing that valid rows follow only 2 patterns (ABA and ABC), we reduce the problem from exponential to linear time complexity using elegant transition rules!

Asked in

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

The optimal solution uses pattern recognition to identify that valid rows have only two types: ABA (6 ways) and ABC (6 ways). By tracking transitions between these pattern types with dynamic programming, we achieve O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Pattern Recognition)	O(n)	O(1)	Recognize that valid rows fall into two pattern types and track transitions

Dynamic Programming (Pattern Recognition) — Algorithm Steps

Identify that valid 3-cell rows have only 2 pattern types: ABA and ABC
Count valid rows of each type: 6 ABA patterns, 6 ABC patterns
Calculate transition rules: ABA→ABA (3 ways), ABA→ABC (2 ways), ABC→ABA (2 ways), ABC→ABC (2 ways)
Use DP to compute total ways for n rows using matrix exponentiation concept

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Patterns

ABA and ABC are the only valid row patterns

Count Each Type

6 ways for ABA, 6 ways for ABC

Calculate Transitions

Apply transition rules to get next row counts

Code -

solution.c — C

#include <stdio.h>

#define MOD 1000000007

int numWaysToColorGrid(int n) {
    if (n == 1) return 12;
    
    long long abaWays = 6;
    long long abcWays = 6;
    
    for (int i = 2; i <= n; i++) {
        long long newAbaWays = (abaWays * 3 + abcWays * 2) % MOD;
        long long newAbcWays = (abaWays * 2 + abcWays * 2) % MOD;
        
        abaWays = newAbaWays;
        abcWays = newAbcWays;
    }
    
    return (abaWays + abcWays) % MOD;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through n rows, doing constant work per row using the transition rules

✓ Linear Growth

Space Complexity

O(1)

We only need to track counts for two pattern types at any time

✓ Linear Space

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

Dynamic Programming (Pattern Recognition) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler