Painting a Grid With Three Different Colors

Painting a Grid With Three Different Colors - Problem

Dynamic Programming Hard

You are given two integers m and n. Consider an m x n grid where each cell is initially white.

You can paint each cell red, green, or blue. All cells must be painted.

Return the number of ways to color the grid with no two adjacent cells having the same color. Since the answer can be very large, return it modulo 10⁹ + 7.

Two cells are adjacent if they share a side (horizontally or vertically adjacent).

Input & Output

Example 1 — Small Grid

$ Input: m = 1, n = 1

› Output: 3

💡 Note: Single cell can be colored in 3 ways: red, green, or blue

Example 2 — Single Row

$ Input: m = 1, n = 2

› Output: 6

💡 Note: Two adjacent cells must have different colors: RG, RB, GR, GB, BR, BG (6 ways)

Example 3 — Two Rows

$ Input: m = 1, n = 3

› Output: 12

💡 Note: For 3 cells in a row: first cell has 3 choices, each subsequent cell has 2 choices (must be different from previous cell). Total: 3×2×2 = 12 ways.

Constraints

1 ≤ m ≤ 5
1 ≤ n ≤ 1000
The answer is guaranteed to be within the range of a 32-bit integer after taking modulo 10⁹ + 7

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 A Amazon 8

The key insight is to use dynamic programming with state compression. Each row can be represented as a state, and we compute transitions between compatible states. The optimal approach uses bottom-up DP with O(m × S²) time complexity where S ≤ 3^n is the number of valid row states.

Common Approaches

✓ Bottom-Up Dynamic Programming

⏱️ Time: O(m × S²) Space: O(S)

Represent each possible column coloring as a state. For each row, calculate how many ways we can transition from previous row states to current row states, ensuring no adjacent cells have same color.

Brute Force Recursion

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

For each cell, try all 3 colors and recursively solve the remaining grid. Check if current color conflicts with adjacent cells that are already colored.

Memoization (Top-Down DP)

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

Use recursion with memoization to store results of subproblems. Each subproblem is defined by current position and the coloring of previous cells that affect current choices.

Bottom-Up Dynamic Programming — Algorithm Steps

Generate all valid colorings for a single row
For each row, compute transitions from previous row
Sum up valid transitions to get count for current row
Return total count for last row

Visualization

Tap to expand

Step-by-Step Walkthrough

States

Generate all valid single-row colorings

Transitions

Find compatible state pairs between rows

Build

Accumulate counts row by row

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_STATES 1000

int validStates[MAX_STATES][10];
int numStates = 0;
int n;

void backtrack(int pos, int* current) {
    if (pos == n) {
        memcpy(validStates[numStates], current, n * sizeof(int));
        numStates++;
        return;
    }
    
    for (int color = 1; color <= 3; color++) {
        if (pos == 0 || current[pos-1] != color) {
            current[pos] = color;
            backtrack(pos + 1, current);
        }
    }
}

void generateValidRowColorings() {
    numStates = 0;
    int current[10];
    backtrack(0, current);
}

int areCompatible(int* row1, int* row2) {
    for (int i = 0; i < n; i++) {
        if (row1[i] == row2[i]) return 0;
    }
    return 1;
}

int solution(int m, int cols) {
    n = cols;
    generateValidRowColorings();
    
    if (m == 1) return numStates % MOD;
    
    long long prevDp[MAX_STATES];
    for (int i = 0; i < numStates; i++) {
        prevDp[i] = 1;
    }
    
    for (int row = 1; row < m; row++) {
        long long currDp[MAX_STATES];
        memset(currDp, 0, sizeof(currDp));
        
        for (int currState = 0; currState < numStates; currState++) {
            for (int prevState = 0; prevState < numStates; prevState++) {
                if (areCompatible(validStates[prevState], validStates[currState])) {
                    currDp[currState] = (currDp[currState] + prevDp[prevState]) % MOD;
                }
            }
        }
        
        memcpy(prevDp, currDp, sizeof(currDp));
    }
    
    long long result = 0;
    for (int i = 0; i < numStates; i++) {
        result = (result + prevDp[i]) % MOD;
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(m × S²)

For each row m, we check transitions between all state pairs, where S ≤ 3^n valid states

✓ Linear Growth

Space Complexity

O(S)

Store DP array for current and previous row states, where S ≤ 3^n

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~35 min Avg. Time

856 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

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler