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

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

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

<p>Return <code>true</code> <em>if it is possible to fit the stamps while following the given restrictions and requirements. Otherwise, return</em> <code>false</code>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/11/03/ex1.png" style="width: 180px; height: 237px;" />
<pre>
<strong>Input:</strong> 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
<strong>Output:</strong> true
<strong>Explanation:</strong> We have two overlapping stamps (labeled 1 and 2 in the image) that are able to cover all the empty cells.
</pre>

<p><strong class="example">Example 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/11/03/ex2.png" style="width: 170px; height: 179px;" />
<pre>
<strong>Input:</strong> grid = [[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]], stampHeight = 2, stampWidth = 2 
<strong>Output:</strong> false 
<strong>Explanation:</strong> There is no way to fit the stamps onto all the empty cells without the stamps going outside the grid.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>m == grid.length</code></li>
	<li><code>n == grid[r].length</code></li>
	<li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li>
	<li><code>1 &lt;= m * n &lt;= 2 * 10<sup>5</sup></code></li>
	<li><code>grid[r][c]</code> is either <code>0</code> or <code>1</code>.</li>
	<li><code>1 &lt;= stampHeight, stampWidth &lt;= 10<sup>5</sup></code></li>
</ul>

class Solution:
    def possibleToStamp(self, grid: List[List[int]], stampHeight: int, stampWidth: int) -> bool:

        def findSum(r1, c1 ,r2, c2):
            if(r1 == 0 and c1 == 0):
                return grid[r2][c2]
            elif(r1 == 0):
                return grid[r2][c2] - grid[r2][c1-1]
            elif(c1 == 0):
                return grid[r2][c2] - grid[r1-1][c2] 
            return grid[r2][c2] - grid[r2][c1-1] - grid[r1-1][c2] + grid[r1-1][c1-1] 



        newGrid = []
        for i in range(len(grid)):
            newGrid.append(grid[i].copy())
        
        for i in range(len(grid)):
            for j in range(1, len(grid[i])):
                grid[i][j] += grid[i][j-1]
        
        for i in range(len(grid[0])):
            for j in range(1, len(grid)):
                grid[j][i] += grid[j-1][i]
        
        
        for i in range(len(grid)):
            for j in range(len(grid[i])):
                if (i + stampHeight <= len(grid) and j + stampWidth <= len(grid[0])):
                    if(findSum(i, j, i + stampHeight - 1, j + stampWidth - 1) == 0):
                        newGrid[i][j] = 2

        for i in range(len(grid)):
            maxRight = 0
            for j in range(len(grid[i])):
                if(newGrid[i][j] == 1):
                    maxRight = 0
                elif(newGrid[i][j] == 2):
                    maxRight = stampWidth
                if(maxRight > 0):
                    newGrid[i][j] = 2
                    maxRight -= 1
        for i in range(len(grid[0])):
            for j in range(len(grid)):
                if(newGrid[j][i] == 1):
                    maxRight = 0
                elif(newGrid[j][i] == 2):
                    maxRight = stampHeight
                if(maxRight > 0):
                    newGrid[j][i] = 2
                    maxRight -= 1
        for i in range(len(grid)):
            for j in range(len(grid[i])):
                if(newGrid[i][j] == 0):
                    return False
        return True
45100