1class Solution {
2    public int[][] minAbsDiff(int[][] grid, int k) {
3        int m = grid.length;       // Number of rows
4        int n = grid[0].length;    // Number of columns
5
6        // Result matrix to hold the minimum absolute difference for each k x k submatrix
7        int[][] ans = new int[m - k + 1][n - k + 1];
8
9        // Traverse all possible top-left corners of k x k submatrices
10        for (int row = 0; row <= m - k; row++) {
11            for (int col = 0; col <= n - k; col++) {
12                List<Integer> elements = new ArrayList<>();
13
14                // Collect all elements in the current k x k submatrix
15                for (int i = row; i < row + k; i++) {
16                    for (int j = col; j < col + k; j++) {
17                        elements.add(grid[i][j]);
18                    }
19                }
20
21                // Sort elements to facilitate comparison of adjacent values
22                Collections.sort(elements);
23
24                int minDiff = Integer.MAX_VALUE;
25                for (int idx = 1; idx < elements.size(); idx++) {
26                    int prev = elements.get(idx - 1);
27                    int curr = elements.get(idx);
28                    // Consider only distinct values
29                    if (prev != curr) {
30                        minDiff = Math.min(minDiff, Math.abs(curr - prev));
31                    }
32                }
33
34                // If all values are the same (minDiff unchanged), store 0, else store minDiff
35                ans[row][col] = (minDiff == Integer.MAX_VALUE) ? 0 : minDiff;
36            }
37        }
38        return ans;
39    }
40}
41

1class Solution {
2public:
3    vector<vector<int>> minAbsDiff(vector<vector<int>>& grid, int k) {
4        int m = grid.size();
5        int n = grid[0].size();
6        // Answer matrix to store minimum absolute difference for each k x k window
7        vector<vector<int>> ans(m - k + 1, vector<int>(n - k + 1, 0));
8
9        // Traverse all possible k x k submatrices
10        for (int i = 0; i <= m - k; ++i) {
11            for (int j = 0; j <= n - k; ++j) {
12                vector<int> elements;
13                // Collect all elements inside the current k x k window
14                for (int x = i; x < i + k; ++x) {
15                    for (int y = j; y < j + k; ++y) {
16                        elements.push_back(grid[x][y]);
17                    }
18                }
19                // Sort window elements to compute minimum difference efficiently
20                sort(elements.begin(), elements.end());
21
22                int minDiff = INT_MAX;
23                // Find the minimum absolute difference between any two different numbers
24                for (int t = 1; t < elements.size(); ++t) {
25                    if (elements[t] != elements[t - 1]) {
26                        minDiff = min(minDiff, abs(elements[t] - elements[t - 1]));
27                    }
28                }
29                // If all elements are the same, set difference to 0
30                ans[i][j] = (minDiff == INT_MAX) ? 0 : minDiff;
31            }
32        }
33        return ans;
34    }
35};
36

1/**
2 * Given a 2D grid and an integer k, for each k x k subgrid, compute the minimal absolute difference
3 * between any two distinct numbers in that subgrid.
4 * @param grid - 2D array of numbers
5 * @param k - Size of the subgrid (k x k)
6 * @returns A 2D array representing minimal absolute difference for each subgrid
7 */
8function minAbsDiff(grid: number[][], k: number): number[][] {
9    const rows: number = grid.length;
10    const cols: number = grid[0].length;
11    // Output array, sized to the number of k x k subgrids that fit in grid
12    const result: number[][] = Array.from({ length: rows - k + 1 }, () => Array(cols - k + 1).fill(0));
13
14    // Iterate over all possible top-left corners of k x k subgrids
15    for (let i = 0; i <= rows - k; i++) {
16        for (let j = 0; j <= cols - k; j++) {
17            const values: number[] = [];
18            // Collect all numbers within this k x k subgrid
19            for (let x = i; x < i + k; x++) {
20                for (let y = j; y < j + k; y++) {
21                    values.push(grid[x][y]);
22                }
23            }
24            // Sort numbers to efficiently compute minimal difference
25            values.sort((a, b) => a - b);
26
27            let minDiff: number = Number.MAX_SAFE_INTEGER;
28            // Find minimal absolute difference between any pair of distinct numbers
29            for (let idx = 1; idx < values.length; idx++) {
30                if (values[idx] !== values[idx - 1]) {
31                    minDiff = Math.min(minDiff, Math.abs(values[idx] - values[idx - 1]));
32                }
33            }
34            // If all numbers are the same, set minDiff to 0
35            result[i][j] = minDiff === Number.MAX_SAFE_INTEGER ? 0 : minDiff;
36        }
37    }
38    return result;
39}
40