Minimum Absolute Difference in Sliding Submatrix

Minimum Absolute Difference in Sliding Submatrix - Problem

You are given an m × n integer matrix grid and an integer k.

For every contiguous k × k submatrix of grid, compute the minimum absolute difference between any two distinct values within that submatrix.

Return a 2D array ans of size (m - k + 1) × (n - k + 1), where ans[i][j] is the minimum absolute difference in the submatrix whose top-left corner is (i, j) in grid.

Note: If all elements in the submatrix have the same value, the answer will be 0.

Input & Output

Example 1 — Basic 3×3 Grid with k=2

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

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

💡 Note: Four 2×2 submatrices: top-left [[1,2],[4,5]] has min diff = min(|1-2|,|1-4|,|1-5|,|2-4|,|2-5|,|4-5|) = 1, 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 — 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 minimum absolute difference is 0 for all 2×2 submatrices

Example 3 — Single Submatrix

$ Input: grid = [[1,5],[3,7]], k = 2

› Output: [[2]]

💡 Note: Only one 2×2 submatrix: [[1,5],[3,7]]. Check pairs: |1-5|=4, |1-3|=2, |1-7|=6, |5-3|=2, |5-7|=2, |3-7|=4. Minimum is 2

Constraints

m == grid.length
n == grid[i].length
1 ≤ k ≤ min(m, n)
1 ≤ grid[i][j] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 12 A Apple 8

The key insight is that after sorting values in each submatrix, the minimum absolute difference must occur between adjacent elements. The optimal approach extracts all k² values from each submatrix, sorts them, then checks only adjacent pairs. Time: O(m×n×k²×log k), Space: O(k²)

Common Approaches

✓ Brute Force

⏱️ Time: O(m×n×k⁴) Space: O(k²)

For each possible k×k submatrix position, extract all values and compare every pair to find the minimum absolute difference. This straightforward approach examines all combinations.

Sort Then Compare Adjacent

⏱️ Time: O(m×n×k²×log(k²)) Space: O(k²)

Instead of comparing all pairs, sort the values in each k×k submatrix first. The minimum difference will always be between adjacent elements in the sorted array, reducing comparisons significantly.

Brute Force — Algorithm Steps

Iterate through all valid top-left positions
Extract all k×k values for each position
Compare every pair to find minimum difference

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Submatrix

Get all k² values from current position

Compare All Pairs

Check every pair combination

Find Minimum

Track the smallest difference found

Code -

solution.c — C

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

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    
    while (*p) {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        if (*p == '\0') break;
        
        // Parse number
        char* endptr;
        int val = (int)strtol(p, &endptr, 10);
        if (endptr != p) {
            arr[(*size)++] = val;
            p = endptr;
        } else {
            break;
        }
    }
}

int** parseGrid(const char* gridStr, int* m, int* n) {
    int len = strlen(gridStr);
    char* cleaned = (char*)malloc((len + 1) * sizeof(char));
    strncpy(cleaned, gridStr + 1, len - 2);
    cleaned[len - 2] = '\0';
    
    int** grid = (int**)malloc(100 * sizeof(int*));
    *m = 0;
    *n = 0;
    
    int start = 0;
    int cleanedLen = strlen(cleaned);
    
    while (start < cleanedLen) {
        int openBracket = -1;
        for (int i = start; i < cleanedLen; i++) {
            if (cleaned[i] == '[') {
                openBracket = i;
                break;
            }
        }
        if (openBracket == -1) break;
        
        int closeBracket = -1;
        for (int i = openBracket; i < cleanedLen; i++) {
            if (cleaned[i] == ']') {
                closeBracket = i;
                break;
            }
        }
        if (closeBracket == -1) break;
        
        int rowLen = closeBracket - openBracket - 1;
        char* rowStr = (char*)malloc((rowLen + 1) * sizeof(char));
        strncpy(rowStr, cleaned + openBracket + 1, rowLen);
        rowStr[rowLen] = '\0';
        
        int* row = (int*)malloc(100 * sizeof(int));
        int rowSize = 0;
        parseArray(rowStr, row, &rowSize);
        
        if (rowSize > 0) {
            grid[*m] = row;
            if (*n == 0) *n = rowSize;
            (*m)++;
        } else {
            free(row);
        }
        
        free(rowStr);
        start = closeBracket + 1;
    }
    
    free(cleaned);
    return grid;
}

int** solution(int** grid, int m, int n, int k, int* returnSize, int** returnColumnSizes) {
    int resultRows = m - k + 1;
    int resultCols = n - k + 1;
    
    int** result = (int**)malloc(resultRows * sizeof(int*));
    *returnColumnSizes = (int*)malloc(resultRows * sizeof(int));
    
    for (int i = 0; i <= m - k; i++) {
        result[i] = (int*)malloc(resultCols * sizeof(int));
        (*returnColumnSizes)[i] = resultCols;
        
        for (int j = 0; j <= n - k; j++) {
            int values[k * k];
            int valueCount = 0;
            
            for (int r = i; r < i + k; r++) {
                for (int c = j; c < j + k; c++) {
                    values[valueCount++] = grid[r][c];
                }
            }
            
            int minDiff = INT_MAX;
            for (int x = 0; x < valueCount; x++) {
                for (int y = x + 1; y < valueCount; y++) {
                    int diff = values[x] - values[y];
                    if (diff < 0) diff = -diff;
                    if (diff < minDiff) {
                        minDiff = diff;
                    }
                }
            }
            
            result[i][j] = (minDiff == INT_MAX) ? 0 : minDiff;
        }
    }
    
    *returnSize = resultRows;
    return result;
}

int main() {
    char line1[10000];
    char line2[100];
    
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    line1[strcspn(line1, "\n")] = '\0';
    line2[strcspn(line2, "\n")] = '\0';
    
    int m, n;
    int** grid = parseGrid(line1, &m, &n);
    int k = atoi(line2);
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(grid, m, n, k, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    for (int i = 0; i < m; i++) {
        free(grid[i]);
    }
    free(grid);
    
    for (int i = 0; i < returnSize; i++) {
        free(result[i]);
    }
    free(result);
    free(returnColumnSizes);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n×k⁴)

For each of (m-k+1)×(n-k+1) positions, we compare k²×(k²-1)/2 pairs

✓ Linear Growth

Space Complexity

O(k²)

Temporary array to store k² values from each submatrix

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler