LeetCode 3567.子矩阵的最小绝对差：暴力模拟

【LetMeFly】3567.子矩阵的最小绝对差：暴力模拟

力扣题目链接：https://leetcode.cn/problems/minimum-absolute-difference-in-sliding-submatrix/

给你一个 m x n 的整数矩阵 grid 和一个整数 k。

对于矩阵 grid 中的每个连续的 k x k 子矩阵 ，计算其中任意两个不同值之间的 最小绝对差。

返回一个大小为 (m - k + 1) x (n - k + 1) 的二维数组 ans，其中 ans[i][j] 表示以 grid 中坐标 (i, j) 为左上角的子矩阵的最小绝对差。

注意：如果子矩阵中的所有元素都相同，则答案为 0。

子矩阵 (x1, y1, x2, y2) 是一个由选择矩阵中所有满足 x1 <= x <= x2 且 y1 <= y <= y2 的单元格 matrix[x][y] 组成的矩阵。

示例 1：
输入： grid = $\[1,8$ , $3,-2$ ], k = 2

输出： $\[2$ ]

解释：

只有一个可能的 k x k 子矩阵：[[1, 8], [3, -2]]。
子矩阵中的不同值为 [1, 8, 3, -2]。
子矩阵中的最小绝对差为 |1 - 3| = 2。因此，答案为 [[2]]。

示例 2：
输入： grid = $\[3,-1$ ], k = 1

输出： $\[0,0$ ]

解释：

每个 k x k 子矩阵中只有一个不同的元素。
因此，答案为 [[0, 0]]。

示例 3：
输入： grid = $\[1,-2,3$ , $2,3,5$ ], k = 2

输出： $\[1,2$ ]

解释：

有两个可能的 k × k 子矩阵：

复制代码

<ul>
	<li>以 <code>(0, 0)</code> 为起点的子矩阵：<code>[[1, -2], [2, 3]]</code>。

	<ul>
		<li>子矩阵中的不同值为 <code>[1, -2, 2, 3]</code>。</li>
		<li>子矩阵中的最小绝对差为 <code>|1 - 2| = 1</code>。</li>
	</ul>
	</li>
	<li>以 <code>(0, 1)</code> 为起点的子矩阵：<code>[[-2, 3], [3, 5]]</code>。
	<ul>
		<li>子矩阵中的不同值为 <code>[-2, 3, 5]</code>。</li>
		<li>子矩阵中的最小绝对差为 <code>|3 - 5| = 2</code>。</li>
	</ul>
	</li>
</ul>
</li>
<li>因此，答案为 <code>[[1, 2]]</code>。</li>

提示：

1 <= m == grid.length <= 30
1 <= n == grid[i].length <= 30
-10⁵ <= grid[i][j] <= 10⁵
1 <= k <= min(m, n)

解题方法：暴力模拟

大小为 n × m n\times m n×m的矩阵共有 ( n − k + 1 ) × ( m − k + 1 ) (n-k+1)\times(m-k+1) (n−k+1)×(m−k+1)个 k × k k\times k k×k大小的子矩阵，枚举每个子矩阵并将子矩阵所有元素放入一个临时数组，对这个数组排序看相邻且不同元素的最小diff。

时间复杂度 O ( ( n − k ) ( m − k ) k 2 log ⁡ k ) O((n-k)(m-k)k^2\log k) O((n−k)(m−k)k2logk)
空间复杂度 O ( k 2 ) O(k^2) O(k2)

AC代码

C++

cpp 复制代码

/*
 * @LastEditTime: 2026-03-20 23:24:53
 */
class Solution {
public:
    vector<vector<int>> minAbsDiff(vector<vector<int>>& grid, int k) {
        int n = grid.size(), m = grid[0].size();
        vector<vector<int>> ans(n - k + 1, vector<int>(m - k + 1));
        for (int i = 0; i < n - k + 1; i++) {
            for (int j = 0; j < m - k + 1; j++) {
                vector<int> vals;
                vals.reserve(k * k);
                for (int di = 0; di < k; di++) {
                    for (int dj = 0; dj < k; dj++) {
                        vals.push_back(grid[i + di][j + dj]);
                    }
                }
                sort(vals.begin(), vals.end());
                int diff = 1000000;
                for (int i = 1; i < k * k; i++) {
                    int this_diff = vals[i] - vals[i - 1];
                    if (this_diff) {
                        diff = min(diff, abs(this_diff));
                    }
                }
                ans[i][j] = diff == 1000000 ? 0 : diff;
            }
        }
        return ans;
    }
};

同步发文于CSDN和我的个人博客，原创不易，转载经作者同意后请附上原文链接哦~

千篇源码题解已开源