Stamping the Grid

Stamping the Grid - Problem

You are given an m x n binary matrix grid where each cell is either 0 (empty) or 1 (occupied).

You are then given stamps of size stampHeight x stampWidth. We want to fit the stamps such that they follow the given restrictions and requirements:

Cover all the empty cells.
Do not cover any of the occupied cells.
We can put as many stamps as we want.
Stamps can overlap with each other.
Stamps are not allowed to be rotated.
Stamps must stay completely inside the grid.

Return true if it is possible to fit the stamps while following the given restrictions and requirements. Otherwise, return false.

Input & Output

Example 1 — Basic Case

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

› Output: true

💡 Note: We can place 1×3 stamps at positions (0,1), (1,1), and (2,1) to cover all empty cells without covering any occupied cells

Example 2 — Impossible Case

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

› Output: false

💡 Note: No 2×2 stamp can be placed without covering at least one occupied cell (1), so it's impossible to cover all empty cells

Example 3 — Small Stamp

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

› Output: true

💡 Note: 1×1 stamps can be placed at all empty positions (0,1), (0,2), (1,1), (1,2), (2,1), (2,2) to cover everything

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⁵

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12

The key insight is that an empty cell can be covered if there exists at least one valid stamp position that includes it. The optimal approach uses prefix sums for O(1) rectangle queries to check stamp validity and difference arrays to efficiently track coverage. Time: O(mn), Space: O(mn)

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(m²n²) Space: O(mn)

For each possible stamp position, check if it's valid (no occupied cells), then mark all positions that can be covered by valid stamps. Finally verify all empty cells are covered.

Prefix Sum Optimization

⏱️ Time: O(mn) Space: O(mn)

Build 2D prefix sum arrays to quickly determine if a stamp can be placed (no occupied cells in rectangle) and efficiently track which cells can be covered by valid stamp positions.

Brute Force Simulation — Algorithm Steps

Check each possible stamp position for validity
Mark all cells that can be covered by valid stamps
Verify all empty cells are covered

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Position

Test if stamp can be placed at current position

Mark Coverage

If valid, mark all cells this stamp would cover

Verify

Check if all empty cells are covered

Code -

solution.c — C

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

static int grid[1000][1000];
static bool covered[1000][1000];

bool canPlace(int m, int n, int r, int c, int stampHeight, int stampWidth) {
    if (r + stampHeight > m || c + stampWidth > n) return false;
    for (int i = r; i < r + stampHeight; i++) {
        for (int j = c; j < c + stampWidth; j++) {
            if (grid[i][j] == 1) return false;
        }
    }
    return true;
}

bool solution(int m, int n, int stampHeight, int stampWidth) {
    // Initialize covered array
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            covered[i][j] = false;
        }
    }
    
    // Try placing stamp at each position
    for (int r = 0; r < m; r++) {
        for (int c = 0; c < n; c++) {
            if (canPlace(m, n, r, c, stampHeight, stampWidth)) {
                // Mark all cells covered by this stamp
                for (int i = r; i < r + stampHeight; i++) {
                    for (int j = c; j < c + stampWidth; j++) {
                        covered[i][j] = true;
                    }
                }
            }
        }
    }
    
    // Check if all empty cells are covered
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 0 && !covered[i][j]) {
                return false;
            }
        }
    }
    
    return true;
}

int parseGrid(char* line, int* m, int* n) {
    *m = 0;
    *n = 0;
    
    if (strcmp(line, "[]") == 0) return 0;
    
    char* ptr = line;
    int row = 0, col = 0;
    
    // Skip first '['
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr) ptr++;
    
    while (*ptr != '\0') {
        if (*ptr == '[') {
            // Start of new row
            col = 0;
            ptr++;
        } else if (*ptr == ']') {
            // End of row
            if (*n == 0) *n = col;
            row++;
            ptr++;
            // Skip comma after ]
            if (*ptr == ',') ptr++;
        } else if (*ptr >= '0' && *ptr <= '9') {
            // Parse number
            char* endptr;
            int num = strtol(ptr, &endptr, 10);
            grid[row][col++] = num;
            ptr = endptr;
        } else {
            // Skip other characters (spaces, commas)
            ptr++;
        }
    }
    
    *m = row;
    return 1;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Remove newline
    int len = strlen(line);
    if (len > 0 && line[len-1] == '\n') {
        line[len-1] = '\0';
    }
    
    int m, n;
    parseGrid(line, &m, &n);
    
    int stampHeight, stampWidth;
    scanf("%d", &stampHeight);
    scanf("%d", &stampWidth);
    
    bool result = solution(m, n, stampHeight, stampWidth);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

Nested loops check every position for every stamp placement

⚠ Quadratic Growth

Space Complexity

O(mn)

Coverage tracking matrix of same size as grid

⚡ Linearithmic Space

23.0K Views

Medium Frequency

~35 min Avg. Time

890 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler