Minimum Absolute Difference in Sliding Submatrix

Minimum Absolute Difference in Sliding Submatrix - Problem

Imagine you're analyzing data patterns in a grid where you need to find the closest values within every possible square window of size k x k.

Given an m x n integer matrix grid and an integer k, your task is to:

Examine every contiguous k x k submatrix within the grid
For each submatrix, find the minimum absolute difference between any two distinct values
Return a 2D result array where each position represents the minimum difference for the submatrix starting at that position

Key Points:

If all elements in a submatrix are identical, the minimum difference is 0
The result matrix has dimensions (m - k + 1) x (n - k + 1)
Each result position [i][j] corresponds to the submatrix with top-left corner at (i, j)

Example: For a 4x4 grid with k=2, you'll have 9 different 2x2 submatrices to analyze, resulting in a 3x3 answer matrix.

Input & Output

example_1.py — Basic 3×3 Matrix

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

› Output: [[1,1],[1,1]]

💡 Note: For k=2, we have four 2×2 submatrices. Top-left [1,2,4,5] has min diff 1 (between 1&2 or 4&5). Top-right [2,3,5,6] has min diff 1. Bottom-left [4,5,7,8] has min diff 1. Bottom-right [5,6,8,9] has min diff 1.

example_2.py — Same Values

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

› Output: [[0,0],[0,0]]

💡 Note: All elements are identical, so the minimum absolute difference in any submatrix is 0.

example_3.py — Large Differences

$ Input: grid = [[1,10,100],[2,20,200],[3,30,300]], k = 2

› Output: [[1,10],[1,10]]

💡 Note: Each 2×2 submatrix contains values with different ranges, but the minimum differences are consistently small due to adjacent row/column values.

Constraints

1 ≤ k ≤ min(m, n) ≤ 100
1 ≤ grid[i][j] ≤ 10⁵
The matrix must be large enough to contain at least one k×k submatrix

Visualization

Tap to expand

Understanding the Visualization

Position Window

Place k×k sliding window at each valid position in matrix

Extract Values

Collect all k² elements from current submatrix window

Sort & Compare

Sort extracted values and check only consecutive pairs

Record Minimum

Store the minimum difference found in result matrix

Key Takeaway

🎯 Key Insight: After sorting elements, minimum absolute difference can only occur between consecutive values, dramatically reducing the search space from all pairs to adjacent pairs only.

Asked in

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

The optimal approach uses sorting + adjacent difference checking for each k×k submatrix. Key insight: the minimum absolute difference between any numbers must occur between consecutive elements when sorted, reducing complexity from O(k⁴) to O(k² log k²) per submatrix.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Adjacent Difference Check (Optimal)	O((m-k+1)×(n-k+1)×k²×log(k²))	O(k²)	Sort elements in each submatrix, then check only consecutive pairs for minimum difference
Brute Force (All Pairs Comparison)	O((m-k+1)×(n-k+1)×k⁴)	O(k²)	For each k×k submatrix, compare every pair of elements to find minimum difference

Sorting + Adjacent Difference Check (Optimal) — Algorithm Steps

Iterate through all possible k×k submatrix positions
For each submatrix, extract all k² elements
Sort the extracted elements
Check differences between consecutive elements in sorted array
The minimum of these consecutive differences is our answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract & Sort

Get elements [1,2,4,5] and sort them

Check Adjacent Pairs

Only compare consecutive: |2-1|, |4-2|, |5-4|

Find Minimum

Minimum of [1, 2, 1] is 1

Next Submatrix

Move sliding window and repeat

Code -

solution.c — C

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

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

int** minimumAbsoluteDifference(int** grid, int gridSize, int* gridColSize, int k, int* returnSize, int** returnColumnSizes) {
    int m = gridSize, n = gridColSize[0];
    *returnSize = m - k + 1;
    *returnColumnSizes = (int*)malloc((*returnSize) * sizeof(int));
    
    int** ans = (int**)malloc((*returnSize) * sizeof(int*));
    for (int i = 0; i < *returnSize; i++) {
        (*returnColumnSizes)[i] = n - k + 1;
        ans[i] = (int*)malloc((n - k + 1) * sizeof(int));
    }
    
    for (int i = 0; i <= m - k; i++) {
        for (int j = 0; j <= n - k; j++) {
            // Extract all elements from k×k submatrix
            int elements[k * k];
            int idx = 0;
            for (int x = i; x < i + k; x++) {
                for (int y = j; y < j + k; y++) {
                    elements[idx++] = grid[x][y];
                }
            }
            
            // Sort elements to find minimum difference efficiently
            qsort(elements, k * k, sizeof(int), compare);
            
            // Check consecutive elements for minimum difference
            int minDiff = INT_MAX;
            for (int p = 0; p < k * k - 1; p++) {
                int diff = elements[p + 1] - elements[p];
                if (diff < minDiff) {
                    minDiff = diff;
                }
            }
            
            ans[i][j] = minDiff == INT_MAX ? 0 : minDiff;
        }
    }
    
    return ans;
}

int main() {
    int grid_data[4][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};
    int* grid[4] = {grid_data[0], grid_data[1], grid_data[2], grid_data[3]};
    int gridColSize[4] = {4, 4, 4, 4};
    int k = 2;
    int returnSize, *returnColumnSizes;
    
    int** result = minimumAbsoluteDifference(grid, 4, gridColSize, k, &returnSize, &returnColumnSizes);
    
    for (int i = 0; i < returnSize; i++) {
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d ", result[i][j]);
        }
        printf("\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((m-k+1)×(n-k+1)×k²×log(k²))

For each submatrix, we sort k² elements which takes O(k² log k²) time

⚡ Linearithmic

Space Complexity

O(k²)

Space needed to store and sort elements of each k×k submatrix

✓ Linear Space

39.0K Views

Medium Frequency

~25 min Avg. Time

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

Sorting + Adjacent Difference Check (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler