Paint Fence

Paint Fence - Problem

Dynamic Programming Medium

You are painting a fence of n posts with k different colors. You must paint the posts following these rules:

Every post must be painted exactly one color
There cannot be three or more consecutive posts with the same color

Given the two integers n and k, return the number of ways you can paint the fence.

Input & Output

Example 1 — Basic Case

$ Input: n = 3, k = 2

› Output: 6

💡 Note: With 3 posts and 2 colors, we can paint: RRG, RGR, RGG, GRR, GRG, GGR (6 ways total, avoiding 3 consecutive same colors)

Example 2 — Single Post

$ Input: n = 1, k = 1

› Output: 1

💡 Note: With 1 post and 1 color, there's only 1 way to paint it

Example 3 — Edge Case

$ Input: n = 3, k = 1

› Output: 0

💡 Note: With only 1 color and 3 posts, we'd have 3 consecutive same colors, which violates the rule

Constraints

1 ≤ n ≤ 50
1 ≤ k ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 20 a Amazon 15

The key insight is to track two patterns: posts ending with same color vs different color than previous post. The optimal bottom-up DP approach uses recurrence relations to build the solution iteratively. Time: O(n), Space: O(1).

Common Approaches

✓ Bottom-Up Dynamic Programming

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

Build solution iteratively by tracking two states: number of ways to paint i posts where the last two have the same color vs different colors.

Brute Force Recursion

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

Recursively try all k colors for each post and check if any 3 consecutive posts have the same color. This explores all k^n possibilities.

Memoization (Top-Down DP)

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

Same recursive approach as brute force but cache results for (position, last_color, consecutive_count) states to avoid recomputing the same subproblems.

Bottom-Up Dynamic Programming — Algorithm Steps

Initialize base cases for first post
For each post, calculate same and different patterns
Use recurrence: same[i] = different[i-1], different[i] = (same[i-1] + different[i-1]) × (k-1)

Visualization

Tap to expand

Step-by-Step Walkthrough

Base Cases

Initialize patterns for first 2 posts

Recurrence

Calculate same and different patterns for each post

Final

Sum both patterns for total ways

Code -

solution.c — C

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

int solution(int n, int k) {
    if (n == 0) {
        return 0;
    }
    if (n == 1) {
        return k;
    }
    if (k == 1) {
        return n <= 2 ? 1 : 0;
    }
    
    // same = ways where last 2 posts have same color
    // diff = ways where last 2 posts have different colors
    int same = k;          // After 2 posts
    int diff = k * (k - 1); // After 2 posts
    
    for (int i = 3; i <= n; i++) {
        int newSame = diff;
        int newDiff = (same + diff) * (k - 1);
        same = newSame;
        diff = newDiff;
    }
    
    return same + diff;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single loop through n posts with constant work per iteration

✓ Linear Growth

Space Complexity

O(1)

Only need to track previous state values, no extra arrays

✓ Linear Space

52.0K Views

Medium Frequency

~25 min Avg. Time

867 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