Skip to content

Commit def4977

Browse files
yanglbmeyanglbme
committed
feat: add solutions for lc No.3567
1 parent c5aeba0 commit def4977

5 files changed

Lines changed: 209 additions & 3 deletions

File tree

‎solution/3500-3599/3567.Minimum Absolute Difference in Sliding Submatrix/README.md‎

Lines changed: 73 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -188,7 +188,7 @@ public:
188188
nums.push_back(grid[x][y]);
189189
}
190190
}
191-
sort(nums.begin(), nums.end());
191+
ranges::sort(nums);
192192
int d = INT_MAX;
193193
for (int t = 1; t < nums.size(); ++t) {
194194
if (nums[t] != nums[t - 1]) {
@@ -275,6 +275,78 @@ function minAbsDiff(grid: number[][], k: number): number[][] {
275275
}
276276
```
277277

278+
#### Rust
279+
280+
```rust
281+
impl Solution {
282+
pub fn min_abs_diff(grid: Vec<Vec<i32>>, k: i32) -> Vec<Vec<i32>> {
283+
let m = grid.len();
284+
let n = grid[0].len();
285+
let k = k as usize;
286+
287+
let mut ans = vec![vec![0; n - k + 1]; m - k + 1];
288+
289+
for i in 0..=m - k {
290+
for j in 0..=n - k {
291+
let mut nums = Vec::with_capacity(k * k);
292+
for x in i..i + k {
293+
for y in j..j + k {
294+
nums.push(grid[x][y]);
295+
}
296+
}
297+
298+
nums.sort_unstable();
299+
300+
let mut d = i32::MAX;
301+
for t in 1..nums.len() {
302+
if nums[t] != nums[t - 1] {
303+
d = d.min((nums[t] - nums[t - 1]).abs());
304+
}
305+
}
306+
307+
ans[i][j] = if d == i32::MAX { 0 } else { d };
308+
}
309+
}
310+
311+
ans
312+
}
313+
}
314+
```
315+
316+
#### Rust
317+
318+
```rust
319+
public class Solution {
320+
public int[][] MinAbsDiff(int[][] grid, int k) {
321+
int m = grid.Length, n = grid[0].Length;
322+
int[][] ans = new int[m - k + 1][];
323+
for (int i = 0; i <= m - k; ++i) {
324+
ans[i] = new int[n - k + 1];
325+
for (int j = 0; j <= n - k; ++j) {
326+
List<int> nums = new List<int>(k * k);
327+
for (int x = i; x < i + k; ++x) {
328+
for (int y = j; y < j + k; ++y) {
329+
nums.Add(grid[x][y]);
330+
}
331+
}
332+
333+
nums.Sort();
334+
335+
int d = int.MaxValue;
336+
for (int t = 1; t < nums.Count; ++t) {
337+
if (nums[t] != nums[t - 1]) {
338+
d = Math.Min(d, Math.Abs(nums[t] - nums[t - 1]));
339+
}
340+
}
341+
342+
ans[i][j] = d == int.MaxValue ? 0 : d;
343+
}
344+
}
345+
return ans;
346+
}
347+
}
348+
```
349+
278350
<!-- tabs:end -->
279351

280352
<!-- solution:end -->

‎solution/3500-3599/3567.Minimum Absolute Difference in Sliding Submatrix/README_EN.md‎

Lines changed: 73 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -184,7 +184,7 @@ public:
184184
nums.push_back(grid[x][y]);
185185
}
186186
}
187-
sort(nums.begin(), nums.end());
187+
ranges::sort(nums);
188188
int d = INT_MAX;
189189
for (int t = 1; t < nums.size(); ++t) {
190190
if (nums[t] != nums[t - 1]) {
@@ -271,6 +271,78 @@ function minAbsDiff(grid: number[][], k: number): number[][] {
271271
}
272272
```
273273

274+
#### Rust
275+
276+
```rust
277+
impl Solution {
278+
pub fn min_abs_diff(grid: Vec<Vec<i32>>, k: i32) -> Vec<Vec<i32>> {
279+
let m = grid.len();
280+
let n = grid[0].len();
281+
let k = k as usize;
282+
283+
let mut ans = vec![vec![0; n - k + 1]; m - k + 1];
284+
285+
for i in 0..=m - k {
286+
for j in 0..=n - k {
287+
let mut nums = Vec::with_capacity(k * k);
288+
for x in i..i + k {
289+
for y in j..j + k {
290+
nums.push(grid[x][y]);
291+
}
292+
}
293+
294+
nums.sort_unstable();
295+
296+
let mut d = i32::MAX;
297+
for t in 1..nums.len() {
298+
if nums[t] != nums[t - 1] {
299+
d = d.min((nums[t] - nums[t - 1]).abs());
300+
}
301+
}
302+
303+
ans[i][j] = if d == i32::MAX { 0 } else { d };
304+
}
305+
}
306+
307+
ans
308+
}
309+
}
310+
```
311+
312+
#### Rust
313+
314+
```rust
315+
public class Solution {
316+
public int[][] MinAbsDiff(int[][] grid, int k) {
317+
int m = grid.Length, n = grid[0].Length;
318+
int[][] ans = new int[m - k + 1][];
319+
for (int i = 0; i <= m - k; ++i) {
320+
ans[i] = new int[n - k + 1];
321+
for (int j = 0; j <= n - k; ++j) {
322+
List<int> nums = new List<int>(k * k);
323+
for (int x = i; x < i + k; ++x) {
324+
for (int y = j; y < j + k; ++y) {
325+
nums.Add(grid[x][y]);
326+
}
327+
}
328+
329+
nums.Sort();
330+
331+
int d = int.MaxValue;
332+
for (int t = 1; t < nums.Count; ++t) {
333+
if (nums[t] != nums[t - 1]) {
334+
d = Math.Min(d, Math.Abs(nums[t] - nums[t - 1]));
335+
}
336+
}
337+
338+
ans[i][j] = d == int.MaxValue ? 0 : d;
339+
}
340+
}
341+
return ans;
342+
}
343+
}
344+
```
345+
274346
<!-- tabs:end -->
275347

276348
<!-- solution:end -->

‎solution/3500-3599/3567.Minimum Absolute Difference in Sliding Submatrix/Solution.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@ class Solution {
1111
nums.push_back(grid[x][y]);
1212
}
1313
}
14-
sort(nums.begin(), nums.end());
14+
ranges::sort(nums);
1515
int d = INT_MAX;
1616
for (int t = 1; t < nums.size(); ++t) {
1717
if (nums[t] != nums[t - 1]) {

‎solution/3500-3599/3567.Minimum Absolute Difference in Sliding Submatrix/Solution.cs‎

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
public class Solution {
2+
public int[][] MinAbsDiff(int[][] grid, int k) {
3+
int m = grid.Length, n = grid[0].Length;
4+
int[][] ans = new int[m - k + 1][];
5+
for (int i = 0; i <= m - k; ++i) {
6+
ans[i] = new int[n - k + 1];
7+
for (int j = 0; j <= n - k; ++j) {
8+
List<int> nums = new List<int>(k * k);
9+
for (int x = i; x < i + k; ++x) {
10+
for (int y = j; y < j + k; ++y) {
11+
nums.Add(grid[x][y]);
12+
}
13+
}
14+
15+
nums.Sort();
16+
17+
int d = int.MaxValue;
18+
for (int t = 1; t < nums.Count; ++t) {
19+
if (nums[t] != nums[t - 1]) {
20+
d = Math.Min(d, Math.Abs(nums[t] - nums[t - 1]));
21+
}
22+
}
23+
24+
ans[i][j] = d == int.MaxValue ? 0 : d;
25+
}
26+
}
27+
return ans;
28+
}
29+
}

‎solution/3500-3599/3567.Minimum Absolute Difference in Sliding Submatrix/Solution.rs‎

Lines changed: 33 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
1+
impl Solution {
2+
pub fn min_abs_diff(grid: Vec<Vec<i32>>, k: i32) -> Vec<Vec<i32>> {
3+
let m = grid.len();
4+
let n = grid[0].len();
5+
let k = k as usize;
6+
7+
let mut ans = vec![vec![0; n - k + 1]; m - k + 1];
8+
9+
for i in 0..=m - k {
10+
for j in 0..=n - k {
11+
let mut nums = Vec::with_capacity(k * k);
12+
for x in i..i + k {
13+
for y in j..j + k {
14+
nums.push(grid[x][y]);
15+
}
16+
}
17+
18+
nums.sort_unstable();
19+
20+
let mut d = i32::MAX;
21+
for t in 1..nums.len() {
22+
if nums[t] != nums[t - 1] {
23+
d = d.min((nums[t] - nums[t - 1]).abs());
24+
}
25+
}
26+
27+
ans[i][j] = if d == i32::MAX { 0 } else { d };
28+
}
29+
}
30+
31+
ans
32+
}
33+
}

0 commit comments

Comments
 (0)