Get Biggest Three Rhombus Sums in a Grid - Practice Coding Problems

Get Biggest Three Rhombus Sums in a Grid - Problem

Array Math Sorting Heap (Priority Queue) Matrix Prefix Sum Medium

You're given an m x n integer matrix grid and need to find the three largest distinct rhombus sums.

A rhombus sum is the sum of elements forming the border of a diamond (square rotated 45°) shape in the grid. The rhombus must have each corner centered in a grid cell.

Valid rhombus shapes include:

Size 0: Single cell (1x1)
Size 1: 5 cells forming a small diamond
Size 2: 13 cells forming a larger diamond
And so on...

Return the three largest distinct rhombus sums in descending order. If there are fewer than three distinct values, return all available sums.

Example: In a 3x3 grid, you might have rhombus sums of [20, 15, 10, 10, 5]. The answer would be [20, 15, 10] (only distinct values).

Input & Output

example_1.py — Basic Grid

$ Input: 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]]

› Output: [228, 216, 211]

💡 Note: The largest rhombus has center (2,2) with size 2, sum = 200+30+40+4+4+5+5+1+1+20+3+3+4+3 = 228. The second largest is center (2,2) size 1, sum = 200+4+5+30+3 = 242. Wait, let me recalculate: the largest distinct sums are 228, 216, and 211.

example_2.py — Small Grid

$ Input: grid = [[1,2,3],[4,5,6],[7,8,9]]

› Output: [20, 9, 8]

💡 Note: In a 3x3 grid, the largest rhombus sum is 20 (border: 2+3+6+9+8+7+4+1 = 40, but this is wrong calculation). Let me recalculate: rhombus centered at (1,1) size 1 gives 2+6+8+4=20, single cells give values 1-9.

example_3.py — Single Cell

$ Input: grid = [[7]]

› Output: [7]

💡 Note: Only one cell exists, so the only possible rhombus sum is 7 (size 0 rhombus). Only one distinct value available.

Visualization

Tap to expand

Understanding the Visualization

Survey the Mining Field

Look at the entire m×n grid as a mining field with valuable minerals in each cell

Plan Diamond Routes

For each position, consider it as a potential center for diamond-shaped mining routes

Calculate Route Values

For each diamond route, sum up the mineral values along the border (the extraction path)

Find Top 3 Distinct Values

Identify the three most valuable distinct mining routes for optimal resource extraction

Key Takeaway

🎯 Key Insight: Each rhombus represents a systematic mining pattern. By checking all possible centers and sizes, we ensure we find the most valuable extraction routes without missing any opportunities.

Time & Space Complexity

Time Complexity

⏱️

O(m * n * min(m,n)²)

We check O(mn) centers, each with O(min(m,n)) sizes, each size taking O(min(m,n)) to traverse

✓ Linear Growth

Space Complexity

O(number of distinct rhombus sums)

We store only distinct sums in a set, which is much less than total possible sums

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 50
1 ≤ grid[i][j] ≤ 10⁵

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal approach systematically generates all possible rhombuses by iterating through each center position and size. For each rhombus, we efficiently traverse its border in 4 diagonal directions, calculate the sum, and use a set to handle distinct values. Finally, we sort and return the top 3 largest distinct sums. Time complexity is O(m×n×min(m,n)²) which is acceptable given the constraint limits.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Single Pass (Optimal)	O(m * n * min(m,n)²)	O(number of distinct rhombus sums)	Calculate all rhombus sums efficiently with proper border traversal and use set for distinct values
Brute Force (Check All Rhombuses)	O(m * n * min(m,n)²)	O(m * n * min(m,n))	Check every possible rhombus at every position and size, calculate border sums

Optimized Single Pass (Optimal) — Algorithm Steps

Iterate through each possible rhombus center position
For each center, calculate maximum possible rhombus size based on grid boundaries
For each size, calculate rhombus border sum by traversing 4 diagonal segments
Use set to store distinct sums automatically
Convert to sorted list and return top 3 values

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Corners

Calculate the 4 corner positions of the rhombus

Traverse Edges

Move along each of the 4 edges systematically

Accumulate Sum

Add each border cell value to running total

Store Distinct

Use set to automatically handle duplicate sums

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int compare(const void* a, const void* b) {
    return (*(int*)b - *(int*)a);
}

int min4(int a, int b, int c, int d) {
    int result = a;
    if (b < result) result = b;
    if (c < result) result = c;
    if (d < result) result = d;
    return result;
}

int getRhombusSum(int** grid, int centerI, int centerJ, int size) {
    if (size == 0) {
        return grid[centerI][centerJ];
    }
    
    int total = 0;
    int directions[4][2] = {{-1, -1}, {-1, 1}, {1, 1}, {1, -1}};
    
    for (int d = 0; d < 4; d++) {
        int i, j;
        // Start from corner of rhombus
        if (d == 0) { // top corner
            i = centerI - size; j = centerJ;
        } else if (d == 1) { // right corner
            i = centerI; j = centerJ + size;
        } else if (d == 2) { // bottom corner
            i = centerI + size; j = centerJ;
        } else { // left corner
            i = centerI; j = centerJ - size;
        }
        
        // Traverse one side of rhombus
        for (int step = 0; step < size; step++) {
            total += grid[i][j];
            i += directions[(d + 1) % 4][0];
            j += directions[(d + 1) % 4][1];
        }
    }
    
    return total;
}

int* getBiggestThree(int** grid, int gridSize, int* gridColSize, int* returnSize) {
    int m = gridSize, n = gridColSize[0];
    int* sums = (int*)malloc(m * n * min4(m, n, m, n) * sizeof(int));
    int sumCount = 0;
    
    // Check all possible rhombus centers and sizes
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            int maxSize = min4(i, j, m - 1 - i, n - 1 - j);
            for (int size = 0; size <= maxSize; size++) {
                int rhombusSum = getRhombusSum(grid, i, j, size);
                sums[sumCount++] = rhombusSum;
            }
        }
    }
    
    // Remove duplicates and sort
    qsort(sums, sumCount, sizeof(int), compare);
    
    int* result = (int*)malloc(3 * sizeof(int));
    int uniqueCount = 0;
    int lastValue = -1;
    
    for (int i = 0; i < sumCount && uniqueCount < 3; i++) {
        if (sums[i] != lastValue) {
            result[uniqueCount++] = sums[i];
            lastValue = sums[i];
        }
    }
    
    *returnSize = uniqueCount;
    free(sums);
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m * n * min(m,n)²)

We check O(mn) centers, each with O(min(m,n)) sizes, each size taking O(min(m,n)) to traverse

✓ Linear Growth

Space Complexity

O(number of distinct rhombus sums)

We store only distinct sums in a set, which is much less than total possible sums

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 50
1 ≤ grid[i][j] ≤ 10⁵

31.5K Views

Medium Frequency

~25 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized Single Pass (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler