Painting a Grid With Three Different Colors

Painting a Grid With Three Different Colors - Problem

Dynamic Programming Hard

Grid Painting Challenge: You're tasked with painting an m × n grid using exactly three colors: red, green, and blue. The challenge? No two adjacent cells can have the same color!

Think of it like creating a colorful mosaic where every cell must be painted, but neighboring cells (horizontally or vertically adjacent) must have different colors. You need to count all possible ways to paint the entire grid following this rule.

Goal: Return the total number of valid coloring arrangements modulo 10⁹ + 7.

Input & Output

example_1.py — Small Grid

$ Input: [1, 1]

› Output: 3

💡 Note: For a 1×1 grid, we can paint the single cell red, green, or blue. All 3 ways are valid since there are no adjacent cells to conflict with.

example_2.py — Row of Two

$ Input: [1, 2]

› Output: 6

💡 Note: For a 1×2 grid (two cells in a row), we have 3 choices for the first cell and 2 choices for the second cell (any color except the first cell's color). Total: 3 × 2 = 6 ways.

example_3.py — Column of Two

$ Input: [2, 1]

› Output: 6

💡 Note: For a 2×1 grid (two cells in a column), similar to the row case: 3 choices for the top cell and 2 choices for the bottom cell. Total: 3 × 2 = 6 ways.

Constraints

1 ≤ m ≤ 5
1 ≤ n ≤ 1000
Answer fits in 32-bit integer after modulo operation
Grid cells must be painted with exactly one of three colors
No two adjacent cells (horizontally or vertically) can have the same color

Visualization

Tap to expand

Understanding the Visualization

Identify Valid Patterns

Find all ways to color a single column with no adjacent same colors

Build Transition Rules

Determine which column patterns can be placed next to each other

Dynamic Programming

Count ways to reach each pattern in the current column from previous column

Accumulate Results

Sum all possibilities in the final column

Key Takeaway

🎯 Key Insight: Instead of checking all 3^(m×n) colorings, we recognize that only the previous column pattern matters for the next column. This transforms an exponential problem into a polynomial one!

Asked in

G Google 45 a Amazon 32 f Meta 28 ⊞ Microsoft 25 Apple 18

The optimal solution uses dynamic programming with state compression. Key insight: represent each column as a pattern and track transitions between valid patterns. This reduces complexity from exponential O(3^m×n) to polynomial O(3^m × m × n), making it efficient even for larger grids.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Color Combinations)	O(3^(m*n))	O(m*n)	Generate all possible 3^(m*n) color combinations and check validity
Dynamic Programming with State Compression (Optimal)	O(3^m × m × n)	O(3^m)	Use DP with bitmask to represent column patterns and transitions

Brute Force (Try All Color Combinations) — Algorithm Steps

Generate all possible color assignments for m*n cells
For each complete coloring, check all adjacent pairs
If no adjacent cells have same color, increment counter
Return total count modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Combinations

Try all 3^(m×n) possible colorings

Validate Each Grid

Check if adjacent cells have different colors

Count Valid Solutions

Increment counter for valid colorings

Code -

solution.c — C

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

#define MOD 1000000007
int count_ways = 0;

int isValid(int grid[][1000], int m, int n) {
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (j + 1 < n && grid[i][j] == grid[i][j + 1]) return 0;
            if (i + 1 < m && grid[i][j] == grid[i + 1][j]) return 0;
        }
    }
    return 1;
}

void backtrack(int grid[][1000], int m, int n, int row, int col) {
    if (row == m) {
        if (isValid(grid, m, n)) {
            count_ways = (count_ways + 1) % MOD;
        }
        return;
    }
    
    int nextRow = col + 1 < n ? row : row + 1;
    int nextCol = col + 1 < n ? col + 1 : 0;
    
    for (int color = 0; color < 3; color++) {
        grid[row][col] = color;
        backtrack(grid, m, n, nextRow, nextCol);
    }
}

int numOfWays(int m, int n) {
    count_ways = 0;
    int grid[1000][1000];
    backtrack(grid, m, n, 0, 0);
    return count_ways;
}

int main() {
    int m, n;
    scanf("[%d, %d]", &m, &n);
    printf("%d\n", numOfWays(m, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^(m*n))

We try all 3^(m*n) possible colorings, each taking O(m*n) time to validate

✓ Linear Growth

Space Complexity

O(m*n)

Space needed to store current grid coloring during recursion

⚡ Linearithmic Space

48.2K Views

Medium-High Frequency

~25 min Avg. Time

1.3K 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 (Try All Color Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler