Paint House

Paint House - Problem

There is a row of n houses, where each house can be painted one of three colors: red, blue, or green.

The cost of painting each house with a certain color is different. You have to paint all the houses such that no two adjacent houses have the same color.

The cost of painting each house with a certain color is represented by an n x 3 cost matrix costs. For example, costs[0][0] is the cost of painting house 0 with the color red; costs[1][2] is the cost of painting house 1 with color green, and so on.

Return the minimum cost to paint all houses.

Input & Output

Example 1 — Basic Three Houses

$ Input: costs = [[17,2,17],[16,16,5],[14,3,19]]

› Output: 10

💡 Note: Paint house 0 blue (cost 2), house 1 green (cost 5), house 2 blue (cost 3). Total cost = 2 + 5 + 3 = 10.

Example 2 — Single House

$ Input: costs = [[7,6,2]]

› Output: 2

💡 Note: Only one house, so paint it with the cheapest color (green, cost 2).

Example 3 — Two Houses

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

› Output: 18

💡 Note: Paint house 0 red (cost 5), house 1 green (cost 13). Total cost = 5 + 13 = 18.

Constraints

1 ≤ costs.length ≤ 100
costs[i].length == 3
1 ≤ costs[i][j] ≤ 20

Visualization

Tap to expand

Asked in

F Facebook 45 a Amazon 35 G Google 30 M Microsoft 25

The key insight is that this is a dynamic programming problem where each house's optimal cost depends only on the previous house. The space-optimized DP approach is optimal with Time: O(n), Space: O(1).

Common Approaches

✓ 2D Dynamic Programming

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

Create a DP table where dp[i][j] represents minimum cost to paint houses 0 to i with house i painted in color j. Fill table bottom-up using previous row values.

Brute Force Recursion

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

For each house, try painting it with each of the three colors, then recursively solve for remaining houses. This explores all 3^n possible combinations.

Memoization (Top-Down DP)

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

Same recursive approach but cache results for each (house, previous_color) state. This eliminates redundant calculations when the same subproblem is encountered multiple times.

Space-Optimized DP

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

Since we only need the previous row to calculate current row, we can optimize space by using just two arrays or even reusing the input array in place.

2D Dynamic Programming — Algorithm Steps

Create DP table dp[n][3]
Initialize first row with costs[0]
Fill each row using minimum from previous row (excluding same color)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

First row equals costs of first house

Fill Table

Each cell = current cost + min of previous row (different colors)

Result

Minimum value in last row

Code -

solution.c — C

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

int min(int a, int b) {
    return a < b ? a : b;
}

int solution(int** costs, int n) {
    if (n == 0) return 0;
    
    int** dp = malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        dp[i] = malloc(3 * sizeof(int));
    }
    
    // Initialize first house
    for (int j = 0; j < 3; j++) {
        dp[0][j] = costs[0][j];
    }
    
    // Fill DP table
    for (int i = 1; i < n; i++) {
        dp[i][0] = costs[i][0] + min(dp[i-1][1], dp[i-1][2]);
        dp[i][1] = costs[i][1] + min(dp[i-1][0], dp[i-1][2]);
        dp[i][2] = costs[i][2] + min(dp[i-1][0], dp[i-1][1]);
    }
    
    int result = min(dp[n-1][0], min(dp[n-1][1], dp[n-1][2]));
    
    for (int i = 0; i < n; i++) free(dp[i]);
    free(dp);
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int** costs = NULL;
    int n = 0;
    char* ptr = line + 1;
    while (*ptr && *ptr != ']') {
        costs = realloc(costs, (n + 1) * sizeof(int*));
        costs[n] = malloc(3 * sizeof(int));
        if (*ptr == '[') ptr++;
        sscanf(ptr, "%d,%d,%d", &costs[n][0], &costs[n][1], &costs[n][2]);
        n++;
        while (*ptr && *ptr != ']') ptr++;
        if (*ptr == ']') ptr++;
        if (*ptr == ',') ptr++;
    }
    
    printf("%d\n", solution(costs, n));
    for (int i = 0; i < n; i++) free(costs[i]);
    free(costs);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through n houses, constant work per house

✓ Linear Growth

Space Complexity

O(n)

DP table stores 3 values for each of n houses

⚡ Linearithmic Space

89.6K Views

High Frequency

~15 min Avg. Time

2.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

2D Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler