Paint House II

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.

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?

Visualization

Tap to expand

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

✓ Brute Force (Try All Combinations)

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

This approach generates every possible way to color the houses and checks which combination gives the minimum cost while satisfying the adjacency constraint. For each house, we try all k colors, leading to k^n total combinations.

Optimized Dynamic Programming (Constant Space)

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

This is the optimal solution that improves upon the basic DP approach. Instead of storing the entire DP table and scanning all k colors for each house, we only track the minimum and second minimum costs from the previous house. This reduces both time complexity to O(nk) and space complexity to O(1).

Dynamic Programming (Bottom-Up)

⏱️ Time: O(n*k²) Space: O(n*k)

This approach uses dynamic programming to avoid recalculating the same subproblems. We maintain a DP table where dp[i][j] represents the minimum cost to paint houses 0 to i with house i painted in color j. For each house, we only need to consider the minimum costs from the previous house with different colors.

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible color combinations for n houses with k colors
For each combination, check if adjacent houses have different colors
Calculate the total cost for valid combinations
Return the minimum cost found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at House 0

Try all k colors for the first house

Move to House 1

For each color chosen in house 0, try all valid colors for house 1

Continue Recursively

Repeat for all houses, creating a tree of k^n combinations

Find Minimum

Return the path with minimum total cost

Code -

solution.c — C

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

int backtrack(int** costs, int n, int k, int house, int prevColor) {
    if (house == n) return 0;
    
    int minCost = INT_MAX;
    for (int color = 0; color < k; color++) {
        if (color != prevColor) {
            int cost = costs[house][color] + backtrack(costs, n, k, house + 1, color);
            if (cost < minCost) minCost = cost;
        }
    }
    return minCost;
}

int minCostII(int** costs, int n, int k) {
    if (n == 0) return 0;
    return backtrack(costs, n, k, 0, -1);
}

int main() {
    // Example usage
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

For each of n houses, we try k colors, leading to k^n combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth is n (one call per house)

⚡ Linearithmic 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler