<p>You are given an <code>m x n</code> integer matrix <code>grid</code>​​​.</p>

<p>A <strong>rhombus sum</strong> is the sum of the elements that form <strong>the</strong> <strong>border</strong> of a regular rhombus shape in <code>grid</code>​​​. The rhombus must have the shape of a square rotated 45 degrees with each of the corners centered in a grid cell. Below is an image of four valid rhombus shapes with the corresponding colored cells that should be included in each <strong>rhombus sum</strong>:</p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/04/23/pc73-q4-desc-2.png" style="width: 385px; height: 385px;" />
<p>Note that the rhombus can have an area of 0, which is depicted by the purple rhombus in the bottom right corner.</p>

<p>Return <em>the biggest three <strong>distinct rhombus sums</strong> in the </em><code>grid</code><em> in <strong>descending order</strong></em><em>. If there are less than three distinct values, return all of them</em>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/04/23/pc73-q4-ex1.png" style="width: 360px; height: 361px;" />
<pre>
<strong>Input:</strong> grid = [[3,4,5,1,3],[3,3,4,2,3],[20,30,200,40,10],[1,5,5,4,1],[4,3,2,2,5]]
<strong>Output:</strong> [228,216,211]
<strong>Explanation:</strong> The rhombus shapes for the three biggest distinct rhombus sums are depicted above.
- Blue: 20 + 3 + 200 + 5 = 228
- Red: 200 + 2 + 10 + 4 = 216
- Green: 5 + 200 + 4 + 2 = 211
</pre>

<p><strong class="example">Example 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/04/23/pc73-q4-ex2.png" style="width: 217px; height: 217px;" />
<pre>
<strong>Input:</strong> grid = [[1,2,3],[4,5,6],[7,8,9]]
<strong>Output:</strong> [20,9,8]
<strong>Explanation:</strong> The rhombus shapes for the three biggest distinct rhombus sums are depicted above.
- Blue: 4 + 2 + 6 + 8 = 20
- Red: 9 (area 0 rhombus in the bottom right corner)
- Green: 8 (area 0 rhombus in the bottom middle)
</pre>

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

<pre>
<strong>Input:</strong> grid = [[7,7,7]]
<strong>Output:</strong> [7]
<strong>Explanation:</strong> All three possible rhombus sums are the same, so return [7].
</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;= 50</code></li>
	<li><code>1 &lt;= grid[i][j] &lt;= 10<sup>5</sup></code></li>
</ul>

from heapq import *

class Solution:
    def getBiggestThree(self, grid: List[List[int]]) -> List[int]:
        def rhombusSum(centerI, centerJ, size):
            if centerI - (size - 1) < 0 or centerI + (size - 1) >= n or \
                centerJ - (size - 1) < 0 or centerJ + (size - 1) >= m:
                print("Out of bounds")
                return None
            leftI, leftJ = centerI, centerJ-(size-1)
            topI, topJ = centerI-(size-1), centerJ
            bottomI, bottomJ = centerI+(size-1), centerJ
            rightI, rightJ = centerI, centerJ + (size-1)

            top = grid[topI][topJ]
            bottom = grid[bottomI][bottomJ]
            left = grid[leftI][leftJ]
            right = grid[rightI][rightJ]

            if size == 2:
                return top + left + bottom + right
            
            s = 0
            # Top Left side
            i, j = leftI, leftJ
            while i >= topI and j <= topJ:
                s += grid[i][j]
                i -= 1
                j += 1
            
            # Bottom Right side
            i, j = bottomI, bottomJ
            while i >= rightI and j <= rightJ:
                s += grid[i][j]
                i -= 1
                j += 1

            # Bottom Left side
            i, j = bottomI-1, bottomJ-1
            while i > leftI and j > leftJ:
                s += grid[i][j]
                i -= 1
                j -= 1
            
            # Top Right side
            i, j = rightI-1, rightJ-1
            while i > topI and j > topJ:
                s += grid[i][j]
                i -= 1
                j -= 1
            return s

        heap = []
        n, m = len(grid), len(grid[0])
        maxSize = min(n, m)//2 + 1
        for size in range(1, maxSize+1):
            if size == 1:
                for i in range(n):
                    for j in range(m):
                        if grid[i][j] not in heap:
                            heappush(heap, grid[i][j])
                        if len(heap) > 3:
                            heappop(heap)
            else:
                iStart = size-1
                iEnd = n-1-(size-1)
                jStart = size-1
                jEnd = m-1-(size-1)
                for i in range(iStart, iEnd + 1):
                    for j in range(jStart, jEnd+1):
                        s = rhombusSum(i, j, size)
                        if s not in heap:
                            heappush(heap, s)
                        if len(heap) > 3:
                            heappop(heap)
        print(n, m, maxSize)
        return sorted(heap, reverse=True)


17100