<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>

class Solution:
    def maxScore(self, grid: List[List[int]]) -> int:

        # SHORTCUT 1:
        # we are allowed any number (>=1) of moves.
        # if we move, say, three times, from cell A -> B -> C -> D,
        # our total score will be:
        # B-A + C-B + D-C
        # everything cancels out except for D-A
        # therefore we *do not* have to keep track of multiple possible moves
        # we can merely do one single move, from a cell to any other
        # cell that is *anywhere* below or to its right.
        # This gets rid of the "did I move yet" thing as well
        # as the entire recursion thing.
        # In addition, the cell we want to move to, will always be the
        # cell with the largest score in the allowable portion of the grid.

        # SHORTCUT 2:
        # *do* keep a recursive sum-up of "max number in grid below/right of cell X,Y"
        # ... or possibly of "min number above,left of X,Y inclusive", which is easier
        
        grid_min_by_row = [
            tuple(accumulate(row, min))
            for row in grid
        ]
        # print(f'{grid_min_by_row=}')

        INVERT = lambda x: tuple(zip(*x))

        INV_grid_min_by_row = INVERT(grid_min_by_row)
        # print(f'{INV_grid_min_by_row=}')
        
        INV_grid_min_by_cell = [
            tuple(accumulate(row, min))
            for row in INV_grid_min_by_row
        ]
        # print(f'{INV_grid_min_by_cell=}')

        grid_min_by_cell = INVERT(INV_grid_min_by_cell)
        # print(f'{grid_min_by_cell=}')

        M = len(grid)
        N = len(grid[0])
        print(f'{M=} x {N=} = {M * N}')

        answers = [
            # row -1, same col
            c2 - c1
            for c1row, c2row in zip(grid_min_by_cell, grid[1:])
            for c1, c2 in zip(c1row, c2row)
        ] + [
            # same row, col -1
            c2 - c1
            for c1row, c2row in zip(grid_min_by_cell, grid)
            for c1, c2 in zip(c1row, c2row[1:])
        ]
        # print(f'{answers=}')

        answer = max(answers)
        return answer

943