Paint House IV

Paint House IV - Problem

You're tasked with painting houses in a neighborhood to create the most beautiful arrangement possible while minimizing costs. Given n houses (where n is even) arranged in a straight line, you need to paint each house with one of three colors (Red, Green, or Blue).

The neighborhood will look beautiful if two strict conditions are met:

Adjacent Constraint: No two neighboring houses can have the same color
Mirror Constraint: Houses that are equidistant from the ends must have different colors

For example, with 6 houses: houses at positions (0,5), (1,4), and (2,3) are equidistant pairs and must have different colors.

Each house i has different painting costs for each color, given in cost[i][j] where j represents the color (0=Red, 1=Green, 2=Blue).

Goal: Find the minimum cost to paint all houses while satisfying both beauty conditions.

Input & Output

example_1.py — Basic Case

$ Input: cost = [[1,5,3],[2,9,4]]

› Output: 5

💡 Note: Paint house 0 with color 0 (cost=1) and house 1 with color 2 (cost=4). Total cost = 1+4 = 5. Adjacent constraint: 0≠2 ✓, Mirror constraint: 0≠2 ✓

example_2.py — Four Houses

$ Input: cost = [[1,2,3],[1,4,6],[2,3,1],[4,2,1]]

› Output: 6

💡 Note: Optimal solution: colors [0,1,2,1] with costs [1,2,1,2]. Adjacent constraints: 0≠1✓, 1≠2✓, 2≠1✓. Mirror constraints: houses(0,3): 0≠1✓, houses(1,2): 1≠2✓. Total cost = 1+2+1+2 = 6.

example_3.py — Minimum Case

$ Input: cost = [[5,8,6],[19,14,13]]

› Output: 18

💡 Note: Two houses: Paint house 0 with color 0 (cost=5) and house 1 with color 2 (cost=13). Adjacent: 0≠2 ✓, Mirror: 0≠2 ✓. Total = 5+13 = 18.

Constraints

n == cost.length
2 ≤ n ≤ 20
n is even
cost[i].length == 3
1 ≤ cost[i][j] ≤ 20

Visualization

Tap to expand

Asked in

G Google 42 f Meta 38 a Amazon 31 ⊞ Microsoft 24

The optimal approach uses dynamic programming with constraint handling. The key insight is to build the solution incrementally while respecting both adjacent constraints (no same colors next to each other) and mirror constraints (equidistant houses must have different colors). While the brute force approach tries all 3^n combinations, the DP solution efficiently explores only valid states, achieving polynomial time complexity instead of exponential.

Common Approaches

✓ Brute Force (Try All Combinations)

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

This approach generates all possible ways to color the houses (3^n combinations) and checks each one to see if it satisfies both the adjacent and mirror constraints. While guaranteed to find the optimal solution, it's extremely inefficient for larger inputs.

Dynamic Programming (Optimal)

⏱️ Time: O(n * 3²) Space: O(n * 3)

This approach uses dynamic programming to solve the problem efficiently. We build the solution by considering constraints incrementally, using memoization to avoid redundant calculations. The key insight is that we can reduce the problem space by leveraging the mirror constraint.

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible color combinations for n houses
For each combination, check adjacent constraint (no same colors next to each other)
Check mirror constraint (equidistant houses have different colors)
Among valid combinations, find the one with minimum total cost

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Combinations

Create all 3^n possible color assignments for houses

Check Constraints

Validate adjacent and mirror constraints for each combination

Find Minimum Cost

Among valid combinations, select the one with lowest total cost

Code -

solution.c — C

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

static int minCost = INT_MAX;
static int costs[25][3];
static int n;

int isValid(int* colors) {
    // Check adjacent constraint
    for (int i = 0; i < n - 1; i++) {
        if (colors[i] == colors[i + 1]) {
            return 0;
        }
    }
    
    // Check mirror constraint
    for (int i = 0; i < n / 2; i++) {
        if (colors[i] == colors[n - 1 - i]) {
            return 0;
        }
    }
    
    return 1;
}

int calculateCost(int* colors) {
    int total = 0;
    for (int i = 0; i < n; i++) {
        total += costs[i][colors[i]];
    }
    return total;
}

void backtrack(int* colors, int pos) {
    if (pos == n) {
        if (isValid(colors)) {
            int currentCost = calculateCost(colors);
            if (currentCost < minCost) {
                minCost = currentCost;
            }
        }
        return;
    }
    
    for (int color = 0; color < 3; color++) {
        colors[pos] = color;
        backtrack(colors, pos + 1);
    }
}

int minCostToPaint() {
    minCost = INT_MAX;
    int colors[25];
    backtrack(colors, 0);
    return minCost;
}

void parseInput(char* input) {
    char* ptr = input;
    n = 0;
    
    // Skip initial '['
    while (*ptr && *ptr != '[') ptr++;
    ptr++;
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            for (int j = 0; j < 3; j++) {
                costs[n][j] = strtol(ptr, &ptr, 10);
                while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
            }
            n++;
            while (*ptr && *ptr != ']') ptr++;
            if (*ptr == ']') ptr++;
            while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
        } else {
            ptr++;
        }
    }
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    parseInput(input);
    printf("%d\n", minCostToPaint());
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

We try all 3^n possible color combinations for n houses

✓ Linear Growth

Space Complexity

O(n)

Space for recursion stack and storing current combination

⚡ Linearithmic Space

52.3K Views

Medium Frequency

~25 min Avg. Time

1.8K 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 Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler