<p>You are given an <code>m x n</code> matrix <code>grid</code> consisting of <strong>positive</strong> integers. You can move from a cell in the matrix to <strong>any</strong> other cell that is either to the bottom or to the right (not necessarily adjacent). The score of a move from a cell with the value <code>c1</code> to a cell with the value <code>c2</code> is <code>c2 - c1</code>.<!-- notionvc: 8819ca04-8606-4ecf-815b-fb77bc63b851 --></p>

<p>You can start at <strong>any</strong> cell, and you have to make <strong>at least</strong> one move.</p>

<p>Return the <strong>maximum</strong> total score you can achieve.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2024/03/14/grid1.png" style="width: 240px; height: 240px;" />
<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">grid = [[9,5,7,3],[8,9,6,1],[6,7,14,3],[2,5,3,1]]</span></p>

<p><strong>Output:</strong> <span class="example-io">9</span></p>

<p><strong>Explanation:</strong> We start at the cell <code>(0, 1)</code>, and we perform the following moves:<br />
- Move from the cell <code>(0, 1)</code> to <code>(2, 1)</code> with a score of <code>7 - 5 = 2</code>.<br />
- Move from the cell <code>(2, 1)</code> to <code>(2, 2)</code> with a score of <code>14 - 7 = 7</code>.<br />
The total score is <code>2 + 7 = 9</code>.</p>
</div>

<p><strong class="example">Example 2:</strong></p>

<p><img alt="" src="https://assets.leetcode.com/uploads/2024/04/08/moregridsdrawio-1.png" style="width: 180px; height: 116px;" /></p>

<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">grid = [[4,3,2],[3,2,1]]</span></p>

<p><strong>Output:</strong> <span class="example-io">-1</span></p>

<p><strong>Explanation:</strong> We start at the cell <code>(0, 0)</code>, and we perform one move: <code>(0, 0)</code> to <code>(0, 1)</code>. The score is <code>3 - 4 = -1</code>.</p>
</div>

<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>2 &lt;= m, n &lt;= 1000</code></li>
	<li><code>4 &lt;= m * n &lt;= 10<sup>5</sup></code></li>
	<li><code>1 &lt;= grid[i][j] &lt;= 10<sup>5</sup></code></li>
</ul>

import numpy as np
from itertools import product
class Solution:
    def maxScore(self, grid: List[List[int]]) -> int:
        # Edge cases
       
        max_total_score: int | float = -np.inf # -np.inf
        H = len(grid); W = len(grid[0]) # 4, 4
        for h_start, w_start in product(range(H-1,-1,-1), range(W-1,-1,-1)): # 3, 1
                # hw_start_min = grid[h_start][w_start]
            if h_start == H - 1 and w_start == W - 1:
                continue
            elif h_start == H - 1:
                max_lower_right = grid[h_start][w_start+1]
            elif w_start == W - 1:
                max_lower_right = grid[h_start+1][w_start]
            else: # In interior so can make a jump
                max_lower_right = max(grid[h_start+1][w_start], grid[h_start][w_start+1])
            max_jump_val = max_lower_right - grid[h_start][w_start]
            max_total_score = max(max_total_score, max_jump_val)
            grid[h_start][w_start] = max(grid[h_start][w_start], max_lower_right)
        return max_total_score


'''
#1 Boundary
Do not update 



starting at position h_start, w_start, the maximum score you can make is
grid[h_start][w_start] - min{grid[h][w] : h >= h_start w >= w_start }

maximum_total_score: int | float = -np.inf
h_start = H-1,....,0
    w_start = W-1,...,0
        # Assume we have already comupted the minimum for {h, w : h > h_start, w > w_start}
        hw_start_min = min{
            grid[h_start][w_start],
            grid[h_start+1][w_start],
            grid[h_start][w_start+ 1],
        }
        # Update the maximum total score if not on the boundary i.e. h_start < H and w_start < W



'''



38900