Paint House IV - Practice Coding Problems

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 [1,0,2,1] with costs [2,1,1,2]. Adjacent: 1≠0, 0≠2, 2≠1 ✓. Mirror: houses(0,3): 1≠1 ✗. Need to try [1,2,0,2]: costs [2,6,2,2]=12. Better: [0,2,1,2]: costs [1,6,3,2]=12. Optimal: [2,1,0,1]: costs [3,4,2,2]=11. Actually optimal is [1,0,2,0]: costs [2,1,1,4]=8. But mirror (1≠0) ✓, adjacent ✓.

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

Understanding the Visualization

Set Up The Street

Visualize houses in a line with mirror positions clearly marked

Apply Local Rules

Ensure no two adjacent houses have the same color

Enforce Symmetry

Make sure houses equidistant from ends have different colors

Optimize Costs

Among all valid arrangements, choose the one with minimum total cost

Key Takeaway

🎯 Key Insight: The problem combines local constraints (adjacent houses) with global symmetry requirements (mirror positions), making it ideal for dynamic programming where we build valid solutions incrementally while tracking both types of constraints.

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

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(3^n)	O(n)	Generate all possible color combinations and check constraints
Dynamic Programming (Optimal)	O(n * 3²)	O(n * 3)	Build solution incrementally using memoization and constraint checking

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>

int minCost = INT_MAX;

int isValid(int* colors, int n) {
    // 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** cost, int n) {
    int total = 0;
    for (int i = 0; i < n; i++) {
        total += cost[i][colors[i]];
    }
    return total;
}

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

int minCostToPaint(int** cost, int n) {
    minCost = INT_MAX;
    int* colors = (int*)malloc(n * sizeof(int));
    backtrack(colors, 0, cost, n);
    free(colors);
    return minCost;
}

int main() {
    int** cost = (int**)malloc(2 * sizeof(int*));
    for (int i = 0; i < 2; i++) {
        cost[i] = (int*)malloc(3 * sizeof(int));
    }
    cost[0][0] = 1; cost[0][1] = 2; cost[0][2] = 3;
    cost[1][0] = 1; cost[1][1] = 4; cost[1][2] = 6;
    
    printf("%d\n", minCostToPaint(cost, 2));
    
    for (int i = 0; i < 2; i++) {
        free(cost[i]);
    }
    free(cost);
    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