<p>You are given a <strong>0-indexed</strong> <code>m x n</code> integer matrix <code>grid</code>. Your initial position is at the <strong>top-left</strong> cell <code>(0, 0)</code>.</p>

<p>Starting from the cell <code>(i, j)</code>, you can move to one of the following cells:</p>

<ul>
	<li>Cells <code>(i, k)</code> with <code>j &lt; k &lt;= grid[i][j] + j</code> (rightward movement), or</li>
	<li>Cells <code>(k, j)</code> with <code>i &lt; k &lt;= grid[i][j] + i</code> (downward movement).</li>
</ul>

<p>Return <em>the minimum number of cells you need to visit to reach the <strong>bottom-right</strong> cell</em> <code>(m - 1, n - 1)</code>. If there is no valid path, return <code>-1</code>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2023/01/25/ex1.png" style="width: 271px; height: 171px;" />
<pre>
<strong>Input:</strong> grid = [[3,4,2,1],[4,2,3,1],[2,1,0,0],[2,4,0,0]]
<strong>Output:</strong> 4
<strong>Explanation:</strong> The image above shows one of the paths that visits exactly 4 cells.
</pre>

<p><strong class="example">Example 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2023/01/25/ex2.png" style="width: 271px; height: 171px;" />
<pre>
<strong>Input:</strong> grid = [[3,4,2,1],[4,2,1,1],[2,1,1,0],[3,4,1,0]]
<strong>Output:</strong> 3
<strong>Explanation: </strong>The image above shows one of the paths that visits exactly 3 cells.
</pre>

<p><strong class="example">Example 3:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2023/01/26/ex3.png" style="width: 181px; height: 81px;" />
<pre>
<strong>Input:</strong> grid = [[2,1,0],[1,0,0]]
<strong>Output:</strong> -1
<strong>Explanation:</strong> It can be proven that no path exists.
</pre>

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

<ul>
	<li><code>m == grid.length</code></li>
	<li><code>n == grid[i].length</code></li>
	<li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li>
	<li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li>
	<li><code>0 &lt;= grid[i][j] &lt; m * n</code></li>
	<li><code>grid[m - 1][n - 1] == 0</code></li>
</ul>

class Solution:

    def minimumVisitedCells(self, grid: List[List[int]]) -> int:
        m = len(grid)
        n = len(grid[0])
        # list of monotonic (increasing by distance) stacks, each stack is a list of (idx,distance) tuples
        h_stacks = [[] for _ in range(m)] 
        v_stacks = [[] for _ in range(n)] 

        def query(stack,max_idx): # returns the minimum distance at or before max_idx
            smin = 0
            smax = len(stack)-1
            while smin <= smax:
                smid = int((smin+smax)/2)
                # want to find stack point where stack[i][0] <= max_idx and stack[i-1][0] > max_idx
                if stack[smid][0] > max_idx: # too low
                    smin = smid+1
                elif smid > 0 and stack[smid-1][0] <= max_idx: # too high
                    smax = smid-1
                else: # perfect
                    return stack[smid][1]
            # there is no cell before max_idx
            return -1
        
        distances = [['?' for _ in range(n)] for _ in range(m)]
        for i in range(m-1,-1,-1):
            for j in range(n-1,-1,-1):
                jump = grid[i][j]
                # get minimum distance to bottom right
                if (i,j) == (m-1,n-1): curr_dist = 1
                else:
                    d1 = query(h_stacks[i],j+jump)
                    d2 = query(v_stacks[j],i+jump)
                    if d1 == -1 and d2 == -1: curr_dist = -1
                    elif d1 == -1: curr_dist = d2+1
                    elif d2 == -1: curr_dist = d1+1
                    else:
                        curr_dist = min(d1,d2)+1
                    if (i,j) == (3,0): print(h_stacks[i],j+jump,d1,d2,curr_dist)
                distances[i][j] = curr_dist
                
                # if answer, return
                if (i,j) == (0,0): 
                    print(distances)
                    return curr_dist

                if curr_dist != -1:
                    # update stacks
                    while h_stacks[i] and h_stacks[i][-1][1] >= curr_dist: h_stacks[i].pop()
                    h_stacks[i].append((j,curr_dist))
                    while v_stacks[j] and v_stacks[j][-1][1] >= curr_dist: v_stacks[j].pop()
                    v_stacks[j].append((i,curr_dist))

        raise Exception('impossible')
2996