Paint House III

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

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

✓ Brute Force (Try All Combinations)

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

Generate all possible ways to paint the unpainted houses, then for each combination, count the neighborhoods and track the minimum cost that achieves exactly the target neighborhoods.

Dynamic Programming (3D DP)

⏱️ Time: O(m × n × target × n) Space: O(m × n × target)

Define dp[i][j][k] as the minimum cost to paint houses 0 to i-1 such that house i-1 has color j and we have exactly k neighborhoods. This eliminates redundant calculations by storing results of subproblems.

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>
#include <ctype.h>
#include <string.h>

int *houses, *current, m, n, target;
int **cost;

int bt(int idx, int total, int hoods) {
    if (idx > 0 && hoods > target) return INT_MAX;
    if (idx == m) return hoods == target ? total : INT_MAX;
    if (houses[idx] != 0) {
        current[idx] = houses[idx];
        int nh = hoods + (idx == 0 || houses[idx] != current[idx-1] ? 1 : 0);
        return bt(idx + 1, total, nh);
    }
    int res = INT_MAX;
    for (int c = 1; c <= n; c++) {
        current[idx] = c;
        int nh = hoods + (idx == 0 || c != current[idx-1] ? 1 : 0);
        int r = bt(idx + 1, total + cost[idx][c-1], nh);
        if (r < res) res = r;
    }
    return res;
}

void parseIntArray(const char *s, int **arr, int *len) {
    *len = 0; int cap = 16;
    *arr = (int*)malloc(cap * sizeof(int));
    const char *p = s;
    while (*p) {
        if (isdigit(*p) || (*p == '-' && isdigit(*(p+1)))) {
            if (*len == cap) { cap *= 2; *arr = (int*)realloc(*arr, cap * sizeof(int)); }
            (*arr)[(*len)++] = atoi(p);
            while (*p && (isdigit(*p) || *p == '-')) p++;
        } else p++;
    }
}

void parse2DArray(const char *s, int ***arr, int *rows, int *cols) {
    *rows = 0; *cols = 0;
    int cap = 16; *arr = (int**)malloc(cap * sizeof(int*));
    int depth = 0; const char *p = s;
    int rowBuf[100], rc = 0;
    while (*p) {
        if (*p == '[') { depth++; if (depth == 2) rc = 0; }
        else if (*p == ']') {
            if (depth == 2) {
                if (*rows == cap) { cap *= 2; *arr = (int**)realloc(*arr, cap * sizeof(int*)); }
                (*arr)[*rows] = (int*)malloc(rc * sizeof(int));
                memcpy((*arr)[*rows], rowBuf, rc * sizeof(int));
                if (*rows == 0) *cols = rc;
                (*rows)++;
            }
            depth--;
        } else if (depth == 2 && (isdigit(*p) || (*p == '-' && isdigit(*(p+1))))) {
            rowBuf[rc++] = atoi(p);
            while (*p && (isdigit(*p) || *p == '-')) p++;
            continue;
        }
        p++;
    }
}

int main() {
    char buf[100000];
    // houses
    fgets(buf, sizeof(buf), stdin);
    parseIntArray(buf, &houses, &m);
    // cost
    fgets(buf, sizeof(buf), stdin);
    int costRows, costCols;
    parse2DArray(buf, &cost, &costRows, &costCols);
    n = costCols;
    // m n target
    fgets(buf, sizeof(buf), stdin);
    sscanf(buf, "%d", &m);
    fgets(buf, sizeof(buf), stdin); sscanf(buf, "%d", &n);
    fgets(buf, sizeof(buf), stdin); sscanf(buf, "%d", &target);
    current = (int*)malloc(m * sizeof(int));
    int ans = bt(0, 0, 0);
    printf("%d\n", ans == INT_MAX ? -1 : ans);
    free(houses); free(current);
    for (int i = 0; i < costRows; i++) free(cost[i]);
    free(cost); 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