Minimum White Tiles After Covering With Carpets

Minimum White Tiles After Covering With Carpets - Problem

Imagine you're a floor designer working on a project where you need to cover white tiles with black carpets to achieve a specific aesthetic. You have a floor represented by a binary string, where:

'0' represents a black tile (already perfect)
'1' represents a white tile (needs to be covered)

You have numCarpets black carpets available, each exactly carpetLen tiles long. Your goal is to strategically place these carpets to minimize the number of visible white tiles.

Key Rules:

Carpets can overlap each other
Each carpet covers carpetLen consecutive tiles
You want to minimize uncovered white tiles

Example: If floor = "10110", numCarpets = 1, carpetLen = 2, you could place the carpet at position 1 to cover tiles [1,2], leaving only 1 white tile visible (at position 4).

Input & Output

example_1.py — Basic Case

$ Input: floor = "10110", numCarpets = 1, carpetLen = 2

› Output: 2

💡 Note: We can place the carpet at position 1 covering tiles [1,2] ("01"), leaving white tiles at positions 0 and 4 visible, for a total of 2 white tiles.

example_2.py — Multiple Carpets

$ Input: floor = "11111", numCarpets = 2, carpetLen = 3

› Output: 0

💡 Note: We can place first carpet at position 0 covering [0,1,2] and second carpet at position 2 covering [2,3,4]. All white tiles are covered (carpets can overlap).

example_3.py — No White Tiles

$ Input: floor = "00000", numCarpets = 3, carpetLen = 2

› Output: 0

💡 Note: All tiles are already black, so no white tiles are visible regardless of carpet placement.

Visualization

Tap to expand

Key Insight: Use DP to find optimal carpet placement minimizing visible white tiles

Understanding the Visualization

Identify White Tiles

Scan the floor to find all white tiles (1s) that need covering

Evaluate Placements

For each position, consider placing a carpet to maximize white tile coverage

Make Optimal Choice

Use DP to choose between placing carpet here or trying next position

Minimize Remaining

Count white tiles that remain uncovered after optimal placement

Key Takeaway

🎯 Key Insight: Dynamic programming allows us to efficiently explore all placement strategies while avoiding redundant computations through memoization.

Time & Space Complexity

Time Complexity

⏱️

O(n × k)

n positions × k carpets states, each computed once

✓ Linear Growth

Space Complexity

O(n × k)

Memoization table stores results for all (position, carpets) pairs

⚡ Linearithmic Space

Constraints

1 ≤ floor.length ≤ 1000
floor[i] is either '0' or '1'
0 ≤ numCarpets ≤ 1000
1 ≤ carpetLen ≤ floor.length
Note: Carpets can overlap each other

Asked in

G Google 42 a Amazon 38 f Meta 28 ⊞ Microsoft 25

This problem is optimally solved using dynamic programming with memoization. The key insight is that at each position, we have two choices: place a carpet or skip. We use memoization to cache results for overlapping subproblems, achieving O(n × k) time complexity where n is floor length and k is number of carpets.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization	O(n × k)	O(n × k)	Optimize brute force by caching results of overlapping subproblems

Dynamic Programming with Memoization — Algorithm Steps

Create a memoization table for (position, carpets_left) states
At each position, decide whether to place carpet or skip
If placing carpet, jump carpetLen positions ahead
Cache and reuse results for identical subproblems
Return minimum white tiles from memoized computation

Visualization

Tap to expand

Step-by-Step Walkthrough

State Definition

Each state is (position, carpets_remaining)

Memoization

Cache results to avoid recomputation

Optimal Substructure

Build solution from smaller subproblems

Code -

solution.c — C

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

#define MAX_N 1001
#define MAX_K 1001

int memo[MAX_N][MAX_K];
int visited[MAX_N][MAX_K];

int dp(char* floor, int pos, int carpetsLeft, int carpetLen, int n) {
    if (pos >= n) return 0;
    if (carpetsLeft == 0) {
        int count = 0;
        for (int i = pos; i < n; i++) {
            if (floor[i] == '1') count++;
        }
        return count;
    }
    
    if (visited[pos][carpetsLeft]) return memo[pos][carpetsLeft];
    
    // Option 1: Don't place carpet
    int result = (floor[pos] == '1' ? 1 : 0) + dp(floor, pos + 1, carpetsLeft, carpetLen, n);
    
    // Option 2: Place carpet
    if (pos + carpetLen <= n) {
        int option2 = dp(floor, pos + carpetLen, carpetsLeft - 1, carpetLen, n);
        result = result < option2 ? result : option2;
    }
    
    visited[pos][carpetsLeft] = 1;
    memo[pos][carpetsLeft] = result;
    return result;
}

int minimumWhiteTiles(char* floor, int numCarpets, int carpetLen) {
    memset(visited, 0, sizeof(visited));
    return dp(floor, 0, numCarpets, carpetLen, strlen(floor));
}

int main() {
    char floor[MAX_N];
    int numCarpets, carpetLen;
    
    fgets(floor, sizeof(floor), stdin);
    char* start = strchr(floor, '"');
    if (start) {
        start++;
        char* end = strchr(start, '"');
        if (end) *end = '\0';
        strcpy(floor, start);
    }
    
    scanf("%d", &numCarpets);
    scanf("%d", &carpetLen);
    
    printf("%d\n", minimumWhiteTiles(floor, numCarpets, carpetLen));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × k)

n positions × k carpets states, each computed once

✓ Linear Growth

Space Complexity

O(n × k)

Memoization table stores results for all (position, carpets) pairs

⚡ Linearithmic Space

Constraints

1 ≤ floor.length ≤ 1000
floor[i] is either '0' or '1'
0 ≤ numCarpets ≤ 1000
1 ≤ carpetLen ≤ floor.length
Note: Carpets can overlap each other

28.4K Views

Medium Frequency

~25 min Avg. Time

856 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 with Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler