Maximum Sum of an Hourglass - Practice Coding Problems

Maximum Sum of an Hourglass - Problem

You are given an m × n integer matrix grid. Your task is to find the maximum sum of elements that form an "hourglass" pattern within the matrix.

An hourglass is a specific 3×3 pattern that looks like this:

a b c
  d
e f g

The hourglass consists of:

Top row: 3 consecutive elements
Middle: 1 element directly below the center of top row
Bottom row: 3 consecutive elements directly below the middle element

Important constraints:

The hourglass cannot be rotated
The entire hourglass must fit within the matrix boundaries
You need to find the hourglass with the maximum sum of its 7 elements

Goal: Return the maximum possible sum among all valid hourglasses in the matrix.

Input & Output

example_1.py — Python

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

› Output: 30

💡 Note: The maximum hourglass sum is 30. One such hourglass is: 6+1+3+2+9+8+7 = 30 (starting at position [0,1])

example_2.py — Python

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

› Output: 35

💡 Note: Only one hourglass is possible in a 3×3 grid: 1+2+3+5+7+8+9 = 35

example_3.py — Python

$ Input: grid = [[-1,-2,-3,-4],[-5,-6,-7,-8],[-9,-10,-11,-12],[-13,-14,-15,-16]]

› Output: -48

💡 Note: With all negative numbers, we want the hourglass with values closest to zero. The maximum sum is -1+(-2)+(-3)+(-6)+(-9)+(-10)+(-11) = -42

Constraints

m == grid.length
n == grid[i].length
3 ≤ m, n ≤ 150
0 ≤ grid[i][j] ≤ 10⁶
The matrix must be large enough to contain at least one hourglass (minimum 3×3)

Visualization

Tap to expand

Understanding the Visualization

Position the Template

Place the hourglass template at each valid 3×3 position starting from top-left

Calculate Collection Value

Sum up the values of the 7 gems that align with the hourglass shape

Track Best Position

Remember the position that gives the highest total value

Move to Next Position

Slide the template to the next valid position and repeat

Key Takeaway

🎯 Key Insight: We must systematically check every valid 3×3 position in the matrix, but only sum the 7 specific elements that form the hourglass pattern (skipping the corners of the 3×3 square).

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 f Meta 18

The optimal approach uses a brute force traversal to check every valid 3×3 position in the matrix. For each position, we calculate the sum of the 7 elements that form the hourglass pattern (3 top + 1 middle + 3 bottom) and track the maximum. Time complexity is O(m×n) where we visit each valid position exactly once.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(m×n)	O(1)	Check every possible 3×3 position and calculate hourglass sum

Brute Force (Nested Loops) — Algorithm Steps

Iterate through all positions (i,j) where i can go from 0 to m-3 and j from 0 to n-3
For each position, calculate the hourglass sum: top row (3 elements) + middle (1 element) + bottom row (3 elements)
Keep track of the maximum sum encountered
Return the maximum sum after checking all positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Valid Positions

Find all positions where a 3×3 hourglass can fit within the matrix boundaries

Calculate Hourglass Sum

For each valid position, sum the 7 elements forming the hourglass pattern

Track Maximum

Keep track of the highest sum found across all positions

Code -

solution.c — C

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

int largestLocal(int** grid, int m, int n) {
    int maxSum = INT_MIN;
    
    // Check all possible 3x3 positions
    for (int i = 0; i <= m - 3; i++) {
        for (int j = 0; j <= n - 3; j++) {
            // Calculate hourglass sum
            int currentSum = 
                // Top row
                grid[i][j] + grid[i][j+1] + grid[i][j+2] +
                // Middle
                grid[i+1][j+1] +
                // Bottom row
                grid[i+2][j] + grid[i+2][j+1] + grid[i+2][j+2];
            
            if (currentSum > maxSum) {
                maxSum = currentSum;
            }
        }
    }
    
    return maxSum;
}

int main() {
    int** grid;
    int m, n;
    // Parse input for 2D array
    printf("%d\n", largestLocal(grid, m, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

We visit each valid position once and do constant work for each hourglass calculation

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track maximum sum and current sum

✓ Linear Space

28.5K Views

Medium Frequency

~12 min Avg. Time

842 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler