Maximum White Tiles Covered by a Carpet - Practice Coding Problems

Maximum White Tiles Covered by a Carpet - Problem

Array Binary Search Greedy Sliding Window Sorting Prefix Sum Medium

Imagine you're an interior designer with a special carpet that you want to place optimally to cover as many white tiles as possible on a floor.

You are given a 2D integer array tiles where tiles[i] = [li, ri] represents that every tile j in the range li ≤ j ≤ ri is colored white. Think of this as continuous segments of white tiles on a number line.

You also have a carpet of fixed length carpetLen that can be placed anywhere on this number line.

Goal: Find the optimal position to place your carpet so that it covers the maximum number of white tiles.

Example: If you have white tile segments [[1,5], [10,11], [12,18]] and a carpet of length 4, you need to find where to place this carpet to cover the most white tiles possible.

Input & Output

example_1.py — Basic Coverage

$ Input: tiles = [[1,5],[10,11],[12,18]], carpetLen = 4

› Output: 4

💡 Note: Place the carpet starting at position 10. It will cover tiles 10,11 (2 tiles) and tiles 12,13 (2 tiles) for a total of 4 white tiles.

example_2.py — Optimal Positioning

$ Input: tiles = [[10,11],[1,1]], carpetLen = 2

› Output: 2

💡 Note: Place the carpet at position 10. It covers tiles 10,11 which gives us 2 white tiles. This is better than covering tile 1 (only 1 tile).

example_3.py — Single Large Segment

$ Input: tiles = [[1,10]], carpetLen = 3

› Output: 3

💡 Note: Place the carpet anywhere within the segment [1,10]. Since the carpet length is 3, it will always cover exactly 3 white tiles from this segment.

Constraints

1 ≤ tiles.length ≤ 5 × 10⁴
tiles[i].length == 2
1 ≤ li ≤ ri ≤ 10⁹
1 ≤ carpetLen ≤ 10⁹
No two tiles overlap (tiles represent disjoint segments)

Visualization

Tap to expand

Key Insight: Only try carpet positions at segment starts📊 Coverage at position 12: [12,15] (4 tiles) + [18,19] (2 tiles) = 6 tiles⚡ Time Complexity: O(n log n) with sorting + sliding window💾 Space Complexity: O(1) additional space needed🏆 Optimal Result: Maximum 6 white tiles can be covered

Understanding the Visualization

Identify Segments

Map out all white tile segments on the number line

Sort by Position

Arrange segments in left-to-right order for efficient processing

Try Key Positions

Only test carpet positions starting at segment boundaries

Calculate Coverage

For each position, efficiently count total covered tiles

Find Maximum

Return the position that gives maximum coverage

Key Takeaway

🎯 Key Insight: The optimal carpet position will always start at a tile segment boundary. By sorting segments and using a sliding window approach, we can efficiently find the maximum coverage in O(n log n) time.

Asked in

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

The optimal approach uses a sliding window with two pointers technique. First, sort the tile segments by start position. Then, for each possible carpet starting position (which only needs to be at tile segment boundaries), use two pointers to efficiently calculate the total coverage. This achieves O(n log n) time complexity due to sorting, making it much faster than the brute force O(n²) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Binary Search Optimization	O(n² log n)	O(n)	Sort tiles and use binary search to efficiently find optimal carpet positions
Sliding Window with Two Pointers	O(n log n)	O(1)	Use sliding window technique to efficiently find maximum coverage
Brute Force (Try All Positions)	O(n × m)	O(1)	Try placing carpet at every possible position and count covered tiles

Sorting + Binary Search Optimization — Algorithm Steps

Sort all tile segments by their start positions
For each tile segment start position, try placing carpet there
Use binary search to find rightmost tile that carpet can cover
Calculate total coverage using prefix sums for efficiency
Return maximum coverage found across all positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Tiles

Sort all tile segments by start position

Try Position

Place carpet at start of each tile segment

Binary Search

Find rightmost tile the carpet can cover

Calculate Coverage

Use prefix sums for quick coverage calculation

Update Maximum

Track the best coverage found

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    int* tileA = (int*)a;
    int* tileB = (int*)b;
    return tileA[0] - tileB[0];
}

int max(int a, int b) { return a > b ? a : b; }

int maxCoveredTiles(int tiles[][2], int tilesSize, int carpetLen) {
    if (tilesSize == 0) return 0;
    
    qsort(tiles, tilesSize, sizeof(tiles[0]), compare);
    
    long long prefix[tilesSize + 1];
    prefix[0] = 0;
    
    for (int i = 0; i < tilesSize; i++) {
        prefix[i + 1] = prefix[i] + (tiles[i][1] - tiles[i][0] + 1);
    }
    
    int maxCovered = 0;
    
    for (int i = 0; i < tilesSize; i++) {
        int carpetStart = tiles[i][0];
        int carpetEnd = carpetStart + carpetLen - 1;
        
        int left = i, right = tilesSize - 1, rightmost = i;
        
        while (left <= right) {
            int mid = (left + right) / 2;
            if (tiles[mid][0] <= carpetEnd) {
                rightmost = mid;
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        
        long long covered = prefix[rightmost + 1] - prefix[i];
        
        if (tiles[rightmost][1] > carpetEnd) {
            int excess = tiles[rightmost][1] - carpetEnd;
            covered -= excess;
        }
        
        maxCovered = max(maxCovered, (int)covered);
    }
    
    return maxCovered;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

Sorting takes O(n log n), then for each of n positions we do O(n log n) binary search

⚠ Quadratic Growth

Space Complexity

O(n)

Space needed for sorting and storing prefix sums

⚡ Linearithmic Space

43.2K Views

Medium-High Frequency

~18 min Avg. Time

1.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

Constraints

Visualization

Related Problems

Common Approaches

Sorting + Binary Search Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler