Paint House II - Practice Coding Problems

Paint House II - Problem

Paint House II is a classic dynamic programming problem where you need to minimize the cost of painting houses while following a constraint.

You're given n houses arranged in a row and k different colors. Each house can be painted with any of the k colors, but here's the catch: no two adjacent houses can have the same color.

The cost of painting each house with a specific color is given in an n × k matrix called costs, where costs[i][j] represents the cost of painting house i with color j.

Goal: Find the minimum total cost to paint all houses while satisfying the adjacency constraint.

Example: If costs = [[17,2,17],[16,16,5],[14,3,19]], you have 3 houses and 3 colors. The optimal solution might be: paint house 0 with color 1 (cost 2), house 1 with color 2 (cost 5), and house 2 with color 1 (cost 3), for a total cost of 10.

Input & Output

example_1.py — Basic Case

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

› Output: 10

💡 Note: Paint house 0 with color 1 (cost=2), house 1 with color 2 (cost=5), house 2 with color 1 (cost=3). Total cost = 2+5+3 = 10. This is optimal since adjacent houses have different colors and total cost is minimized.

example_2.py — Single House

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

› Output: 2

💡 Note: With only one house, we simply choose the cheapest color available, which is color 2 with cost 2. No adjacency constraints apply.

example_3.py — Two Colors Only

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

› Output: 5

💡 Note: With only 2 colors, we alternate: House 0→Color 0 (cost=1), House 1→Color 1 (cost=3), House 2→Color 0 (cost=4). Total = 1+3+1 = 5. Alternative path gives 5+2+4 = 11, so first path is optimal.

Visualization

Tap to expand

Understanding the Visualization

Analyze First House

Look at all color options for the first house and identify the cheapest and second cheapest

Move to Next House

For each color option, use the minimum cost from previous house if it's a different color, otherwise use second minimum

Track Best Options

Keep track of the minimum and second minimum costs for current house to use for next house

Continue Pattern

Repeat this process for all houses, always ensuring adjacent houses have different colors

Key Takeaway

🎯 Key Insight: We only need to track the minimum and second minimum costs from the previous step, not the entire history. This reduces space complexity to O(1) while maintaining optimal O(n×k) time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n*k²)

For each of n houses, we consider k colors, and for each color we scan k-1 previous colors

✓ Linear Growth

Space Complexity

O(n*k)

DP table stores minimum cost for each house-color combination

⚡ Linearithmic Space

Constraints

costs.length == n
costs[i].length == k
1 ≤ n ≤ 100
2 ≤ k ≤ 20
1 ≤ costs[i][j] ≤ 20
Follow-up: Could you solve it in O(nk) time and O(1) space?

Asked in

G Google 45 a Amazon 38 f Facebook 32 ⊞ Microsoft 28

The optimal solution uses dynamic programming with a key optimization: instead of storing the entire DP table, we only track the minimum and second minimum costs from the previous house. This achieves O(n×k) time complexity and O(1) space complexity. For each house and color, we add the minimum cost from the previous house (or second minimum if it's the same color), ensuring no adjacent houses share colors while minimizing total cost.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Bottom-Up)	O(n*k²)	O(n*k)	Build solution from smaller subproblems using memoization
Brute Force (Try All Combinations)	O(k^n)	O(n)	Generate all possible color combinations and pick the one with minimum cost
Optimized Dynamic Programming (Constant Space)	O(n*k)	O(1)	Track only minimum and second minimum from previous row to achieve O(nk) time and O(1) space

Dynamic Programming (Bottom-Up) — Algorithm Steps

Initialize DP table with costs of painting first house
For each subsequent house, calculate minimum cost for each color
For color j at house i, find minimum cost from previous house excluding color j
Return the minimum value from the last row of DP table

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize First Row

Copy costs of first house directly to DP table

Fill Each Row

For each house, calculate min cost for each color

Consider Valid Transitions

Only consider colors from previous house that differ from current

Find Global Minimum

Return minimum value from last row

Code -

solution.c — C

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

int minCostII(int** costs, int n, int k) {
    if (n == 0) return 0;
    if (k == 1 && n > 1) return INT_MAX;
    
    int** dp = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        dp[i] = (int*)malloc(k * sizeof(int));
    }
    
    // Base case
    for (int j = 0; j < k; j++) {
        dp[0][j] = costs[0][j];
    }
    
    // Fill DP table
    for (int i = 1; i < n; i++) {
        for (int j = 0; j < k; j++) {
            dp[i][j] = INT_MAX;
            for (int prevJ = 0; prevJ < k; prevJ++) {
                if (prevJ != j) {
                    int newCost = dp[i-1][prevJ] + costs[i][j];
                    if (newCost < dp[i][j]) {
                        dp[i][j] = newCost;
                    }
                }
            }
        }
    }
    
    int result = INT_MAX;
    for (int j = 0; j < k; j++) {
        if (dp[n-1][j] < result) {
            result = dp[n-1][j];
        }
    }
    
    // Free memory
    for (int i = 0; i < n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*k²)

For each of n houses, we consider k colors, and for each color we scan k-1 previous colors

✓ Linear Growth

Space Complexity

O(n*k)

DP table stores minimum cost for each house-color combination

⚡ Linearithmic Space

Constraints

costs.length == n
costs[i].length == k
1 ≤ n ≤ 100
2 ≤ k ≤ 20
1 ≤ costs[i][j] ≤ 20
Follow-up: Could you solve it in O(nk) time and O(1) space?

58.2K Views

Medium-High Frequency

~25 min Avg. Time

1.5K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming (Bottom-Up) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler