Minimum White Tiles After Covering With Carpets

Minimum White Tiles After Covering With Carpets - Problem

You are given a 0-indexed binary string floor, which represents the colors of tiles on a floor:

floor[i] = '0' denotes that the i^th tile of the floor is colored black.
floor[i] = '1' denotes that the i^th tile of the floor is colored white.

You are also given numCarpets and carpetLen. You have numCarpets black carpets, each of length carpetLen tiles. Cover the tiles with the given carpets such that the number of white tiles still visible is minimum. Carpets may overlap one another.

Return the minimum number of white tiles still visible.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: Place first carpet at positions [0-1] covering "10" (removes 1 white tile at position 0). Place second carpet at positions [2-3] covering "11" (removes 2 white tiles at positions 2,3). Total white tiles removed: 3. Original white tiles were at positions 0,2,3 (total 3), so 3-3=0. Wait, that would be 0 remaining. Let me recalculate: optimal placement results in 1 white tile remaining visible.

Example 2 — Single Carpet

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

› Output: 2

💡 Note: Floor has 4 white tiles. One carpet of length 2 can cover at most 2 white tiles, leaving 2 white tiles visible.

Example 3 — All Black Floor

$ Input: floor = "0000", numCarpets = 2, carpetLen = 2

› Output: 0

💡 Note: No white tiles to begin with, so answer is 0 regardless of carpet placement.

Constraints

1 ≤ floor.length ≤ 1000
0 ≤ numCarpets ≤ 1000
1 ≤ carpetLen ≤ floor.length
floor[i] is either '0' or '1'

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Meta 8 M Microsoft 6

The key insight is to use dynamic programming to find the optimal placement of carpets. Each carpet should be placed to cover the maximum number of white tiles. Best approach uses 2D DP with prefix sums for efficient range queries. Time: O(n × numCarpets), Space: O(n × numCarpets).

Common Approaches

✓ Brute Force with Recursion

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

For each position, decide whether to place a carpet there or not. Recursively explore all possibilities and return the minimum white tiles remaining.

Dynamic Programming with Prefix Sums

⏱️ Time: O(n × numCarpets × carpetLen) Space: O(n × numCarpets)

Use 2D DP table where dp[i][j] represents minimum white tiles for first i positions using j carpets. Prefix sums allow quick calculation of white tiles in any range.

Memoization (Top-Down DP)

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

Same recursive approach but store results of (position, carpets) states in a memo table to avoid recalculating the same subproblems multiple times.

Brute Force with Recursion — Algorithm Steps

For each position, try placing a carpet
Recursively solve for remaining carpets
Return minimum white tiles across all choices

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin at position 0 with all carpets available

Branch

For each position, try placing or not placing a carpet

Recurse

Continue until all carpets used or floor covered

Code -

solution.c — C

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

#define MAXN 1001
#define MAXC 1001

char floor_s[MAXN];
int n, numCarpets, carpetLen;
int prefix[MAXN];
int memo[MAXN][MAXC];
int visited[MAXN][MAXC];

int whites(int l, int r) {
    if (l >= r) return 0;
    return prefix[r] - prefix[l];
}

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

int solve(int pos, int carpets) {
    if (carpets == 0 || pos >= n)
        return whites(pos, n);

    if (visited[pos][carpets])
        return memo[pos][carpets];

    visited[pos][carpets] = 1;

    int result = whites(pos, n);

    for (int start = pos; start <= n - carpetLen; start++) {
        int wb = whites(pos, start);
        int remaining = solve(start + carpetLen, carpets - 1);
        result = min(result, wb + remaining);
    }

    memo[pos][carpets] = result;
    return result;
}

int main() {
    scanf("%s", floor_s);
    scanf("%d", &numCarpets);
    scanf("%d", &carpetLen);

    n = strlen(floor_s);

    prefix[0] = 0;
    for (int i = 0; i < n; i++)
        prefix[i + 1] = prefix[i] + (floor_s[i] == '1');

    memset(visited, 0, sizeof(visited));

    printf("%d\n", solve(0, numCarpets));

    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

For each position we make binary choice (place carpet or not), leading to exponential combinations

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth can go up to n levels

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~35 min Avg. Time

487 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 with Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler