Stamping the Grid - Practice Coding Problems

Stamping the Grid - Problem

Stamping the Grid is a challenging matrix problem that simulates placing rectangular stamps on a grid. You are given an m × n binary matrix where 0 represents empty cells and 1 represents occupied cells.

Your task is to determine if you can place rectangular stamps of size stampHeight × stampWidth to cover all empty cells while following these rules:

✅ Must cover all empty cells (0s)
❌ Cannot cover any occupied cells (1s)
🔄 Stamps can overlap with each other
📐 Stamps cannot be rotated
📦 Stamps must stay completely inside the grid

Return true if it's possible to stamp all empty cells, false otherwise.

Input & Output

example_1.py — Basic Grid

$ Input: grid = [[1,0,0,0],[1,0,0,0],[1,0,0,0],[1,0,0,0],[1,0,0,0]], stampHeight = 4, stampWidth = 3

› Output: true

💡 Note: We can place one 4×3 stamp starting at position (0,1) to cover all the empty cells in columns 1-3. The stamp doesn't overlap with any occupied cells (the 1s in column 0).

example_2.py — Impossible Case

$ Input: grid = [[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]], stampHeight = 2, stampWidth = 2

› Output: false

💡 Note: No 2×2 stamp can be placed without covering at least one occupied cell (1). The diagonal pattern of obstacles makes it impossible to place any stamp.

example_3.py — Multiple Stamps Needed

$ Input: grid = [[1,0,0,1],[0,0,0,0],[0,0,0,0],[1,0,0,1]], stampHeight = 2, stampWidth = 2

› Output: true

💡 Note: We can place a 2×2 stamp at position (1,1) to cover the 2×2 area of empty cells in the middle. This covers all empty cells without touching the occupied corners.

Visualization

Tap to expand

Understanding the Visualization

Identify Obstacles

Mark all occupied cells (furniture) that cannot be covered

Find Valid Tile Positions

Determine all positions where a tile can be placed without hitting obstacles

Check Coverage

Verify that every empty floor space can be covered by at least one valid tile placement

Key Takeaway

🎯 Key Insight: Use 2D prefix sums to transform expensive O(stampHeight×stampWidth) range checks into O(1) operations, making the overall algorithm run in optimal O(m×n) time.

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

Single pass through grid with O(1) range queries using prefix sums

✓ Linear Growth

Space Complexity

O(m*n)

Additional space for prefix sum arrays and coverage matrix

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[r].length
1 ≤ m, n ≤ 10⁵
1 ≤ m * n ≤ 2 * 10⁵
grid[r][c] is either 0 or 1
1 ≤ stampHeight, stampWidth ≤ 10⁵

Asked in

G Google 45 ⊞ Microsoft 38 a Amazon 32 f Meta 28

The optimal solution uses 2D prefix sums to efficiently check stamp placement validity and coverage. Build prefix sum arrays to answer range queries in O(1) time, then verify each empty cell can be covered by at least one valid stamp position. Time complexity: O(m×n).

Common Approaches

Approach	Time	Space	Notes
✓ Prefix Sum Optimization (Optimal)	O(m*n)	O(m*n)	Use 2D prefix sums to efficiently check stamp placement and coverage
Brute Force (Check All Positions)	O(mn2^(m*n))	O(m*n)	Try placing stamps at every possible position and verify coverage

Prefix Sum Optimization (Optimal) — Algorithm Steps

Build 2D prefix sum of the original grid to quickly check stamp validity
For each position, use prefix sum to check if stamp area has any occupied cells
Create a coverage matrix marking where stamps can be placed
Build prefix sum of coverage matrix to check if all empty cells are covered

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Prefix Sum

Create 2D prefix sum array for O(1) range sum queries

Find Valid Positions

Use prefix sum to quickly check if stamp area contains obstacles

Check Coverage

For each empty cell, verify it can be covered by at least one valid stamp position

Code -

solution.c — C

bool possibleToStamp(int** grid, int gridSize, int* gridColSize, int stampHeight, int stampWidth) {
    int m = gridSize, n = gridColSize[0];
    
    // Build 2D prefix sum
    int** prefix = (int**)malloc((m + 1) * sizeof(int*));
    for (int i = 0; i <= m; i++) {
        prefix[i] = (int*)calloc(n + 1, sizeof(int));
    }
    
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            prefix[i][j] = grid[i-1][j-1] + prefix[i-1][j] + prefix[i][j-1] - prefix[i-1][j-1];
        }
    }
    
    // Create coverage matrix
    int** canPlace = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        canPlace[i] = (int*)calloc(n, sizeof(int));
    }
    
    for (int i = 0; i <= m - stampHeight; i++) {
        for (int j = 0; j <= n - stampWidth; j++) {
            int sum = prefix[i + stampHeight][j + stampWidth] - prefix[i][j + stampWidth] 
                    - prefix[i + stampHeight][j] + prefix[i][j];
            if (sum == 0) {
                canPlace[i][j] = 1;
            }
        }
    }
    
    // Build coverage prefix sum
    int** coverPrefix = (int**)malloc((m + 1) * sizeof(int*));
    for (int i = 0; i <= m; i++) {
        coverPrefix[i] = (int*)calloc(n + 1, sizeof(int));
    }
    
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            coverPrefix[i][j] = canPlace[i-1][j-1] + coverPrefix[i-1][j] 
                              + coverPrefix[i][j-1] - coverPrefix[i-1][j-1];
        }
    }
    
    // Check coverage for each empty cell
    bool result = true;
    for (int i = 0; i < m && result; i++) {
        for (int j = 0; j < n && result; j++) {
            if (grid[i][j] == 0) {
                int r1 = (i - stampHeight + 1 > 0) ? i - stampHeight + 1 : 0;
                int c1 = (j - stampWidth + 1 > 0) ? j - stampWidth + 1 : 0;
                int r2 = (m - stampHeight < i) ? m - stampHeight : i;
                int c2 = (n - stampWidth < j) ? n - stampWidth : j;
                
                if (r1 > r2 || c1 > c2) {
                    result = false;
                    break;
                }
                
                int coverSum = coverPrefix[r2+1][c2+1] - coverPrefix[r1][c2+1] 
                             - coverPrefix[r2+1][c1] + coverPrefix[r1][c1];
                if (coverSum == 0) {
                    result = false;
                    break;
                }
            }
        }
    }
    
    // Free memory
    for (int i = 0; i <= m; i++) {
        free(prefix[i]);
        free(coverPrefix[i]);
    }
    for (int i = 0; i < m; i++) {
        free(canPlace[i]);
    }
    free(prefix);
    free(canPlace);
    free(coverPrefix);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

Single pass through grid with O(1) range queries using prefix sums

✓ Linear Growth

Space Complexity

O(m*n)

Additional space for prefix sum arrays and coverage matrix

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[r].length
1 ≤ m, n ≤ 10⁵
1 ≤ m * n ≤ 2 * 10⁵
grid[r][c] is either 0 or 1
1 ≤ stampHeight, stampWidth ≤ 10⁵

67.2K Views

Medium Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Prefix Sum Optimization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler