Paint House III - Practice Coding Problems

Paint House III - Problem

Paint House III is a challenging optimization problem where you need to strategically paint houses to create a specific number of neighborhoods while minimizing cost.

You have a row of m houses, each needing to be painted with one of n colors (labeled 1 to n). Some houses are already painted and cannot be repainted. Your goal is to paint the remaining houses such that you create exactly target neighborhoods with minimum cost.

A neighborhood is a maximal group of consecutive houses painted with the same color. For example: [1,2,2,3,3,2,1,1] has 5 neighborhoods: [1], [2,2], [3,3], [2], [1,1].

Input:
• houses[i]: color of house i (0 if unpainted)
• cost[i][j]: cost to paint house i with color j+1
• target: desired number of neighborhoods

Output: Minimum cost to achieve exactly target neighborhoods, or -1 if impossible.

Input & Output

example_1.py — Basic Case

$ Input: houses = [0,0,0,0,0], cost = [[1,10],[10,1],[10,1],[1,10],[5,1]], m = 5, n = 2, target = 3

› Output: 9

💡 Note: Paint houses as [2,1,1,1,2] to create neighborhoods [2], [1,1,1], [2]. Total cost = 10+1+1+1+1 = 14. But optimal is [1,2,2,1,2] with cost 1+1+1+10+1 = 14. Actually optimal is [2,1,1,2,1] = 10+1+1+10+5 = 27. The actual optimal solution gives cost 9.

example_2.py — Pre-painted Houses

$ Input: houses = [0,2,1,2,0], cost = [[1,10],[10,1],[10,1],[1,10],[5,1]], m = 5, n = 2, target = 3

› Output: 11

💡 Note: Houses are [2,2,1,2,1] after painting first and last houses. This creates neighborhoods [2,2], [1], [2], [1] = 4 neighborhoods, not 3. Need to find optimal way to achieve exactly 3 neighborhoods.

example_3.py — Impossible Case

$ Input: houses = [3,1,2,3], cost = [], m = 4, n = 3, target = 3

› Output: -1

💡 Note: Houses are already painted as [3,1,2,3] creating 4 neighborhoods: [3], [1], [2], [3]. Cannot change to 3 neighborhoods since no houses can be repainted.

Constraints

m == houses.length == cost.length
n == cost[i].length
1 ≤ m ≤ 100
1 ≤ n ≤ 20
1 ≤ target ≤ m
0 ≤ houses[i] ≤ n
1 ≤ cost[i][j] ≤ 10⁴
All houses must be painted with exactly one color

Visualization

Tap to expand

Understanding the Visualization

Survey the Street

Identify which houses already have themes and which need assignment

Plan Districts

Choose themes for unassigned houses to create exactly the target number of districts

Minimize Costs

Use dynamic programming to find the assignment with minimum total renovation cost

Validate Solution

Ensure the final arrangement has exactly the target number of contiguous themed districts

Key Takeaway

🎯 Key Insight: Transform the exponential problem of trying all color combinations into a polynomial dynamic programming solution by tracking three essential states: house position, last color used, and current district count. This reduces complexity from O(n^k) to O(m × n² × target).

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses 3D Dynamic Programming with state dp[house][color][neighborhoods] representing the minimum cost to paint houses 0 to house-1 where the last house has the given color and we have exactly the specified number of neighborhoods. The key insight is tracking neighborhood count changes: when consecutive houses have the same color, neighborhood count stays the same; when different, it increases by 1. Time complexity is O(m × n² × target).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(n^k)	O(k)	Try every possible color assignment for unpainted houses and check neighborhood count
Dynamic Programming (3D DP)	O(m × n × target × n)	O(m × n × target)	Use memoization to track optimal costs for each state (house, color, neighborhoods)

Brute Force (Try All Combinations) — Algorithm Steps

Find all unpainted houses (houses[i] == 0)
Generate all possible color combinations for unpainted houses
For each combination, calculate total painting cost
Count neighborhoods in the resulting house array
Track minimum cost among combinations with target neighborhoods

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Unpainted Houses

Identify houses with value 0 that need painting

Generate Combinations

Create all possible color assignments for unpainted houses

Count Neighborhoods

For each combination, count consecutive same-colored groups

Track Minimum

Keep track of minimum cost achieving target neighborhoods

Code -

solution.c — C

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

int countNeighborhoods(int* houses, int m) {
    if (m == 0) return 0;
    int count = 1;
    for (int i = 1; i < m; i++) {
        if (houses[i] != houses[i-1]) count++;
    }
    return count;
}

int backtrack(int* houses, int** cost, int index, int m, int n, int target, int* current, int currentCost) {
    if (index == m) {
        return countNeighborhoods(current, m) == target ? currentCost : INT_MAX;
    }
    
    if (houses[index] != 0) {
        current[index] = houses[index];
        return backtrack(houses, cost, index + 1, m, n, target, current, currentCost);
    }
    
    int minCost = INT_MAX;
    for (int color = 1; color <= n; color++) {
        current[index] = color;
        int newCost = currentCost + cost[index][color - 1];
        int result = backtrack(houses, cost, index + 1, m, n, target, current, newCost);
        if (result < minCost) minCost = result;
    }
    return minCost;
}

int minCost(int* houses, int** cost, int m, int n, int target) {
    int* current = (int*)malloc(m * sizeof(int));
    int result = backtrack(houses, cost, 0, m, n, target, current, 0);
    free(current);
    return result == INT_MAX ? -1 : result;
}

int main() {
    printf("Implementation ready\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^k)

Where k is the number of unpainted houses and n is the number of colors. We try all n^k combinations.

✓ Linear Growth

Space Complexity

O(k)

Space for recursion stack and storing current combination

✓ Linear Space

31.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 Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler