We use cookies (including Google cookies) to personalize ads and analyze traffic. By continuing to use our site, you accept our Privacy Policy.

SimplyLeet
TagsDisclaimersPrivacyTermsContactAbout Us

Stamping the Grid

Difficulty: Hard

Problem Description

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:

  1. Cover all the empty cells.
  2. Do not cover any of the occupied cells.
  3. We can put as many stamps as we want.
  4. Stamps can overlap with each other.
  5. Stamps are not allowed to be rotated.
  6. 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.

Key Insights

  • The grid can contain both occupied (1) and empty (0) cells.
  • Stamps of fixed dimensions can be placed only on empty cells without overlapping occupied cells.
  • The positioning of the stamps must ensure that all empty cells are covered and no occupied cells are covered.
  • The challenge lies in ensuring that the given stamp dimensions can adequately cover all empty areas in the grid.

Space and Time Complexity

Time Complexity: O(m * n) - We may need to traverse the entire grid to check for coverage. Space Complexity: O(1) - We can use a constant amount of space for our calculations.

Solution

To solve the problem, we can iterate through the grid and check for each empty cell (0) if it can be covered by a stamp of the given size. We will check the boundaries to ensure that the stamp does not overlap with any occupied cells (1).

  1. For each empty cell (0), check if placing a stamp starting from that cell would cover all the required empty cells in its defined area.
  2. If we encounter an occupied cell (1) within the potential stamp area, we cannot place a stamp there and must continue checking other cells.
  3. We can use a greedy algorithm to cover cells starting from the top-left and moving towards the bottom-right of the grid.

Code Solutions

def canStamp(grid, stampHeight, stampWidth):
    m, n = len(grid), len(grid[0])
    
    for i in range(m):
        for j in range(n):
            # Check if we can place a stamp starting at (i, j)
            if grid[i][j] == 0:
                can_place = True
                # Check the stamp area
                for x in range(stampHeight):
                    for y in range(stampWidth):
                        if (i + x >= m) or (j + y >= n) or (grid[i + x][j + y] == 1):
                            can_place = False
                            break
                    if not can_place:
                        break
                
                # If we can place the stamp, mark the cells as covered
                if can_place:
                    for x in range(stampHeight):
                        for y in range(stampWidth):
                            if (i + x < m) and (j + y < n):
                                grid[i + x][j + y] = 2  # Mark as covered
    
    # Check if all empty cells are covered
    for row in grid:
        for cell in row:
            if cell == 0:
                return False
    return True
← Back to All Questions