Painting the Walls - Practice Coding Problems

Painting the Walls - Problem

Imagine you're a contractor managing a painting project with n walls to paint. You have two types of painters at your disposal:

Paid Painter: A skilled professional who paints wall i in time[i] units and charges cost[i] dollars
Free Painter: An apprentice who works for free and paints any wall in exactly 1 unit of time, but can only work when the paid painter is busy

The key insight is that while the paid painter works on one wall, the free painter can simultaneously work on other walls. If the paid painter takes 3 units to paint a wall, the free painter can complete 3 different walls during that same period!

Goal: Find the minimum cost to paint all n walls using this optimal work scheduling.

Input: Two arrays cost[] and time[] where cost[i] and time[i] represent the cost and time for the paid painter to paint wall i.

Output: The minimum total cost to paint all walls.

Input & Output

example_1.py — Basic Case

$ Input: cost = [1,2,3,2], time = [1,2,3,2]

› Output: 3

💡 Note: Paint wall 1 and wall 3 with paid painter. Paid painter takes 2+2=4 time units and costs 2+2=4. During those 4 time units, free painter can paint walls 0 and 2 (2 walls total). Wait, let me recalculate: Actually, paint wall 2 with paid painter (cost=3, time=3), and free painter paints the other 3 walls in those 3 time units. Total cost = 3.

example_2.py — Minimum Case

$ Input: cost = [2,1], time = [1,2]

› Output: 2

💡 Note: Paint wall 0 with paid painter (cost=2, time=1). During that 1 time unit, free painter can paint 1 wall. But we have 2 walls total, so we need the paid painter to paint wall 1 as well. Actually, better: paint wall 1 with paid painter (cost=1, time=2). Free painter can paint wall 0 during those 2 time units. Total cost = 1. Wait, that's not enough time for 1 wall. Let me recalculate: Paint wall 0 (cost=2, time=1) with paid painter. Free painter paints wall 1 in that 1 time unit. Total cost = 2.

example_3.py — Edge Case Single Wall

$ Input: cost = [5], time = [3]

› Output: 5

💡 Note: Only one wall, so paid painter must paint it. Cost = 5. Free painter has nothing to do.

Visualization

Tap to expand

Understanding the Visualization

Evaluate Each Wall

For each wall, consider the trade-off: pay for specialist OR use free capacity

Track Free Capacity

When specialist works for T time units, apprentices can paint T walls for free

Dynamic Programming

Build up optimal solutions: dp[j] = min cost to paint exactly j walls

Final Decision

Choose wall assignments that minimize total cost while painting all walls

Key Takeaway

🎯 Key Insight: Maximize the free painter's productivity by strategically assigning high-time walls to the paid painter, creating more opportunities for free work!

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We have n walls and need to consider up to n remaining walls for each

⚠ Quadratic Growth

Space Complexity

O(n²)

DP table of size n×n, can be optimized to O(n) with 1D array

⚠ Quadratic Space

Constraints

1 ≤ n ≤ 500 where n = cost.length = time.length
1 ≤ cost[i] ≤ 10⁶
1 ≤ time[i] ≤ 500
The free painter can only work when the paid painter is busy

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 29 f Meta 22

The optimal solution uses dynamic programming to model this as a knapsack-like problem. Key insight: when the paid painter works on a wall for time[i] units, the free painter can simultaneously complete time[i] other walls. We track the minimum cost to paint exactly j walls using a 1D DP array, achieving O(n²) time and O(n) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n²)	O(n²)	Use memoized recursion to avoid recalculating subproblems
Brute Force (Try All Combinations)	O(2^n * n)	O(n)	Try every possible assignment of walls to paid vs free painter

Dynamic Programming (Optimal) — Algorithm Steps

Define state: dp[i][j] = minimum cost to handle j walls using walls 0 to i-1
For each wall, decide: use paid painter (cost[i], get time[i]+1 capacity) or skip
Base case: dp[i][0] = 0 (no walls to paint costs nothing)
Return dp[n][n] (paint all n walls using all n wall options)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP Array

dp[j] represents minimum cost to paint j walls

Consider Each Wall

For wall i, decide whether to use paid painter

Update States

If we use paid painter, we can paint time[i]+1 total walls

Get Final Answer

dp[n] contains minimum cost to paint all n walls

Code -

solution.c — C

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

int paintWalls(int* cost, int* time, int n) {
    // dp[j] = minimum cost to paint j walls
    int* dp = malloc((n + 1) * sizeof(int));
    for (int i = 0; i <= n; i++) {
        dp[i] = INT_MAX;
    }
    dp[0] = 0;
    
    for (int i = 0; i < n; i++) {
        int* newDp = malloc((n + 1) * sizeof(int));
        memcpy(newDp, dp, (n + 1) * sizeof(int));
        
        for (int j = 0; j <= n; j++) {
            if (dp[j] != INT_MAX) {
                // Use paid painter for wall i
                int wallsPainted = (j + time[i] + 1 > n) ? n : j + time[i] + 1;
                if (dp[j] + cost[i] < newDp[wallsPainted]) {
                    newDp[wallsPainted] = dp[j] + cost[i];
                }
            }
        }
        
        free(dp);
        dp = newDp;
    }
    
    int result = dp[n];
    free(dp);
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We have n walls and need to consider up to n remaining walls for each

⚠ Quadratic Growth

Space Complexity

O(n²)

DP table of size n×n, can be optimized to O(n) with 1D array

⚠ Quadratic Space

Constraints

1 ≤ n ≤ 500 where n = cost.length = time.length
1 ≤ cost[i] ≤ 10⁶
1 ≤ time[i] ≤ 500
The free painter can only work when the paid painter is busy

67.9K Views

Medium Frequency

~25 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler