Largest Local Values in a Matrix - Practice Coding Problems

Largest Local Values in a Matrix - Problem

Array Matrix Easy

Imagine you're analyzing satellite imagery and need to identify hotspots in a grid-based map. Given an n x n integer matrix grid, your task is to find the maximum value in every possible 3x3 neighborhood.

Create a matrix maxLocal of size (n-2) x (n-2) where each element maxLocal[i][j] represents the largest value found in the 3x3 submatrix centered at position (i+1, j+1) in the original grid.

Visual Example:

Original 4x4 grid:    Result 2x2 grid:
[9,9,8,1]              [9,9]
[5,6,2,6]       →      [8,6]
[8,2,6,4]
[6,2,2,2]

Each value in the result represents the maximum of a 3x3 region from the original matrix.

Input & Output

example_1.py — Basic 4x4 Grid

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

› Output: [[9,9],[8,6]]

💡 Note: First 3x3 region (top-left): max of [9,9,8,5,6,2,8,2,6] = 9. Second 3x3 region (top-right): max of [9,8,1,6,2,6,2,6,4] = 9. Third 3x3 region (bottom-left): max of [5,6,2,8,2,6,6,2,2] = 8. Fourth 3x3 region (bottom-right): max of [6,2,6,2,6,4,2,2,2] = 6.

example_2.py — Minimum Size Grid

$ Input: grid = [[1,1,1],[1,1,1],[1,1,1]]

› Output: [[1]]

💡 Note: For a 3x3 input, we get a 1x1 output. The only 3x3 region is the entire grid, and the maximum value is 1.

example_3.py — Larger Grid with Pattern

$ Input: grid = [[20,8,20,6,16],[8,16,4,12,8],[20,4,20,10,12],[8,12,8,16,4],[16,8,12,4,20]]

› Output: [[20,20,16],[20,20,12],[20,16,16]]

💡 Note: Each position in the result corresponds to the maximum value found in the respective 3x3 region of the original 5x5 grid.

Constraints

n == grid.length == grid[i].length
3 ≤ n ≤ 100
1 ≤ grid[i][j] ≤ 100

Visualization

Tap to expand

Understanding the Visualization

Initialize Result Matrix

Create a (n-2) × (n-2) matrix to store maximum values

Position Sliding Window

Place 3x3 window at each valid position (0,0) to (n-3,n-3)

Find Local Maximum

Scan all 9 cells in current window to find maximum value

Store Result

Place the maximum value in corresponding position of result matrix

Key Takeaway

🎯 Key Insight: By systematically scanning each valid 3×3 region and tracking the maximum value, we can efficiently build the result matrix in O(n²) time complexity.

Asked in

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

The optimal approach uses nested loops to systematically scan each 3x3 region in the matrix. For each valid position, we examine all 9 cells to find the maximum value. The time complexity is O(n²) and space complexity is O(1) excluding output space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Scan every 3x3 submatrix and find maximum in each

Brute Force (Nested Loops) — Algorithm Steps

Initialize result matrix with dimensions (n-2) x (n-2)
For each valid top-left corner (i,j) of a 3x3 region
Scan all 9 cells in the 3x3 region starting at (i,j)
Track the maximum value found in this region
Store the maximum in result[i][j]

Visualization

Tap to expand

Step-by-Step Walkthrough

Position (0,0)

Scan 3x3 region starting at top-left corner

Position (0,1)

Move right and scan next 3x3 region

Continue pattern

Systematically cover all valid positions

Code -

solution.c — C

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

int** largestLocal(int** grid, int gridSize, int* gridColSize, int* returnSize, int** returnColumnSizes) {
    int n = gridSize;
    *returnSize = n - 2;
    *returnColumnSizes = (int*)malloc((*returnSize) * sizeof(int));
    int** maxLocal = (int**)malloc((*returnSize) * sizeof(int*));
    
    for (int i = 0; i < *returnSize; i++) {
        (*returnColumnSizes)[i] = n - 2;
        maxLocal[i] = (int*)malloc((n-2) * sizeof(int));
    }
    
    for (int i = 0; i < n-2; i++) {
        for (int j = 0; j < n-2; j++) {
            int maxVal = 0;
            // Check all 9 cells in the 3x3 region
            for (int r = i; r < i+3; r++) {
                for (int c = j; c < j+3; c++) {
                    if (grid[r][c] > maxVal) {
                        maxVal = grid[r][c];
                    }
                }
            }
            maxLocal[i][j] = maxVal;
        }
    }
    
    return maxLocal;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We visit (n-2)² positions, and for each position we check 9 cells, giving us O((n-2)² × 9) = O(n²)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space besides the output matrix

✓ Linear Space

28.5K Views

Medium Frequency

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