3567. Minimum Absolute Difference in Sliding Submatrix

/**
 * Problem: LeetCode 3567 - Minimum Absolute Difference in Sliding Submatrix
 * Difficulty: Medium
 * Language: Java
 * Author: CodeByTushu
 */
import java.util.Arrays;

class Solution {
    public int[][] minAbsDiff(int[][] grid, int k) {
        int m = grid.length;
        int n = grid[0].length;
        int rows = m - k + 1;
        int cols = n - k + 1;
        int[][] ans = new int[rows][cols];
        int[] window = new int[k * k];

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                int idx = 0;
                for (int r = 0; r < k; r++) {
                    for (int c = 0; c < k; c++) {
                        window[idx++] = grid[i + r][j + c];
                    }
                }

                Arrays.sort(window);
                int minDiff = Integer.MAX_VALUE;

                for (int p = 1; p < window.length; p++) {
                    if (window[p] != window[p - 1]) {
                        int diff = window[p] - window[p - 1];
                        if (diff < minDiff) {
                            minDiff = diff;
                        }
                    }
                }

                ans[i][j] = (minDiff == Integer.MAX_VALUE) ? 0 : minDiff;
            }
        }

        return ans;
    }
}

"""
Problem: LeetCode 3567 - Minimum Absolute Difference in Sliding Submatrix
Difficulty: Medium
Language: Python
Author: CodeByTushu
"""
class Solution:
    def minAbsDiff(self, grid: list[list[int]], k: int) -> list[list[int]]:
        m, n = len(grid), len(grid[0])
        rows = m - k + 1
        cols = n - k + 1
        ans = [[0] * cols for _ in range(rows)]

        for i in range(rows):
            for j in range(cols):
                window = [grid[i + r][j + c] for r in range(k) for c in range(k)]
                window.sort()
                min_diff = float('inf')

                for p in range(1, len(window)):
                    if window[p] != window[p - 1]:
                        diff = window[p] - window[p - 1]
                        if diff < min_diff:
                            min_diff = diff

                ans[i][j] = 0 if min_diff == float('inf') else min_diff

        return ans

/**
 * Problem: LeetCode 3567 - Minimum Absolute Difference in Sliding Submatrix
 * Difficulty: Medium
 * Language: C++
 * Author: CodeByTushu
 */
#include <vector>
#include <algorithm>
#include <climits>

using namespace std;

class Solution {
public:
    vector<vector<int>> minAbsDiff(vector<vector<int>>& grid, int k) {
        int m = grid.size();
        int n = grid[0].size();
        int rows = m - k + 1;
        int cols = n - k + 1;
        vector<vector<int>> ans(rows, vector<int>(cols, 0));
        vector<int> window(k * k);

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                int idx = 0;
                for (int r = 0; r < k; r++) {
                    for (int c = 0; c < k; c++) {
                        window[idx++] = grid[i + r][j + c];
                    }
                }

                sort(window.begin(), window.end());
                int minDiff = INT_MAX;

                for (int p = 1; p < window.size(); p++) {
                    if (window[p] != window[p - 1]) {
                        int diff = window[p] - window[p - 1];
                        if (diff < minDiff) {
                            minDiff = diff;
                        }
                    }
                }

                ans[i][j] = (minDiff == INT_MAX) ? 0 : minDiff;
            }
        }

        return ans;
    }
};

/**
 * Problem: LeetCode 3567 - Minimum Absolute Difference in Sliding Submatrix
 * Difficulty: Medium
 * Language: JavaScript
 * Author: CodeByTushu
 */
var minAbsDiff = function(grid, k) {
    const m = grid.length;
    const n = grid[0].length;
    const rows = m - k + 1;
    const cols = n - k + 1;
    const ans = Array.from({ length: rows }, () => new Array(cols).fill(0));
    const window = new Int32Array(k * k);

    for (let i = 0; i < rows; i++) {
        for (let j = 0; j < cols; j++) {
            let idx = 0;
            for (let r = 0; r < k; r++) {
                for (let c = 0; c < k; c++) {
                    window[idx++] = grid[i + r][j + c];
                }
            }

            window.sort();
            let minDiff = Infinity;

            for (let p = 1; p < window.length; p++) {
                if (window[p] !== window[p - 1]) {
                    const diff = window[p] - window[p - 1];
                    if (diff < minDiff) {
                        minDiff = diff;
                    }
                }
            }

            ans[i][j] = minDiff === Infinity ? 0 : minDiff;
        }
    }

    return ans;
};