Skip to content

Commit 9b7427d

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problems: No.3195,3197
1 parent ac1f60f commit 9b7427d

File tree

9 files changed

+633
-0
lines changed

9 files changed

+633
-0
lines changed

‎solution/3100-3199/3195.Find the Minimum Area to Cover All Ones I/README.md

Lines changed: 78 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -180,6 +180,84 @@ function minimumArea(grid: number[][]): number {
180180
}
181181
```
182182

183+
#### Rust
184+
185+
```rust
186+
impl Solution {
187+
pub fn minimum_area(grid: Vec<Vec<i32>>) -> i32 {
188+
let m = grid.len();
189+
let n = grid[0].len();
190+
let mut x1 = m as i32;
191+
let mut y1 = n as i32;
192+
let mut x2 = 0i32;
193+
let mut y2 = 0i32;
194+
195+
for i in 0..m {
196+
for j in 0..n {
197+
if grid[i][j] == 1 {
198+
x1 = x1.min(i as i32);
199+
y1 = y1.min(j as i32);
200+
x2 = x2.max(i as i32);
201+
y2 = y2.max(j as i32);
202+
}
203+
}
204+
}
205+
206+
(x2 - x1 + 1) * (y2 - y1 + 1)
207+
}
208+
}
209+
```
210+
211+
#### JavaScript
212+
213+
```js
214+
/**
215+
* @param {number[][]} grid
216+
* @return {number}
217+
*/
218+
var minimumArea = function (grid) {
219+
const [m, n] = [grid.length, grid[0].length];
220+
let [x1, y1] = [m, n];
221+
let [x2, y2] = [0, 0];
222+
for (let i = 0; i < m; ++i) {
223+
for (let j = 0; j < n; ++j) {
224+
if (grid[i][j] === 1) {
225+
x1 = Math.min(x1, i);
226+
y1 = Math.min(y1, j);
227+
x2 = Math.max(x2, i);
228+
y2 = Math.max(y2, j);
229+
}
230+
}
231+
}
232+
return (x2 - x1 + 1) * (y2 - y1 + 1);
233+
};
234+
```
235+
236+
#### C#
237+
238+
```cs
239+
public class Solution {
240+
public int MinimumArea(int[][] grid) {
241+
int m = grid.Length, n = grid[0].Length;
242+
int x1 = m, y1 = n;
243+
int x2 = 0, y2 = 0;
244+
245+
for (int i = 0; i < m; ++i) {
246+
for (int j = 0; j < n; ++j) {
247+
if (grid[i][j] == 1) {
248+
x1 = Math.Min(x1, i);
249+
y1 = Math.Min(y1, j);
250+
x2 = Math.Max(x2, i);
251+
y2 = Math.Max(y2, j);
252+
}
253+
}
254+
}
255+
256+
return (x2 - x1 + 1) * (y2 - y1 + 1);
257+
}
258+
}
259+
```
260+
183261
<!-- tabs:end -->
184262

185263
<!-- solution:end -->

‎solution/3100-3199/3195.Find the Minimum Area to Cover All Ones I/README_EN.md

Lines changed: 78 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -178,6 +178,84 @@ function minimumArea(grid: number[][]): number {
178178
}
179179
```
180180

181+
#### Rust
182+
183+
```rust
184+
impl Solution {
185+
pub fn minimum_area(grid: Vec<Vec<i32>>) -> i32 {
186+
let m = grid.len();
187+
let n = grid[0].len();
188+
let mut x1 = m as i32;
189+
let mut y1 = n as i32;
190+
let mut x2 = 0i32;
191+
let mut y2 = 0i32;
192+
193+
for i in 0..m {
194+
for j in 0..n {
195+
if grid[i][j] == 1 {
196+
x1 = x1.min(i as i32);
197+
y1 = y1.min(j as i32);
198+
x2 = x2.max(i as i32);
199+
y2 = y2.max(j as i32);
200+
}
201+
}
202+
}
203+
204+
(x2 - x1 + 1) * (y2 - y1 + 1)
205+
}
206+
}
207+
```
208+
209+
#### JavaScript
210+
211+
```js
212+
/**
213+
* @param {number[][]} grid
214+
* @return {number}
215+
*/
216+
var minimumArea = function (grid) {
217+
const [m, n] = [grid.length, grid[0].length];
218+
let [x1, y1] = [m, n];
219+
let [x2, y2] = [0, 0];
220+
for (let i = 0; i < m; ++i) {
221+
for (let j = 0; j < n; ++j) {
222+
if (grid[i][j] === 1) {
223+
x1 = Math.min(x1, i);
224+
y1 = Math.min(y1, j);
225+
x2 = Math.max(x2, i);
226+
y2 = Math.max(y2, j);
227+
}
228+
}
229+
}
230+
return (x2 - x1 + 1) * (y2 - y1 + 1);
231+
};
232+
```
233+
234+
#### C#
235+
236+
```cs
237+
public class Solution {
238+
public int MinimumArea(int[][] grid) {
239+
int m = grid.Length, n = grid[0].Length;
240+
int x1 = m, y1 = n;
241+
int x2 = 0, y2 = 0;
242+
243+
for (int i = 0; i < m; ++i) {
244+
for (int j = 0; j < n; ++j) {
245+
if (grid[i][j] == 1) {
246+
x1 = Math.Min(x1, i);
247+
y1 = Math.Min(y1, j);
248+
x2 = Math.Max(x2, i);
249+
y2 = Math.Max(y2, j);
250+
}
251+
}
252+
}
253+
254+
return (x2 - x1 + 1) * (y2 - y1 + 1);
255+
}
256+
}
257+
```
258+
181259
<!-- tabs:end -->
182260

183261
<!-- solution:end -->

‎solution/3100-3199/3195.Find the Minimum Area to Cover All Ones I/Solution.cs

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
public class Solution {
2+
public int MinimumArea(int[][] grid) {
3+
int m = grid.Length, n = grid[0].Length;
4+
int x1 = m, y1 = n;
5+
int x2 = 0, y2 = 0;
6+
7+
for (int i = 0; i < m; ++i) {
8+
for (int j = 0; j < n; ++j) {
9+
if (grid[i][j] == 1) {
10+
x1 = Math.Min(x1, i);
11+
y1 = Math.Min(y1, j);
12+
x2 = Math.Max(x2, i);
13+
y2 = Math.Max(y2, j);
14+
}
15+
}
16+
}
17+
18+
return (x2 - x1 + 1) * (y2 - y1 + 1);
19+
}
20+
}

‎solution/3100-3199/3195.Find the Minimum Area to Cover All Ones I/Solution.js

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
/**
2+
* @param {number[][]} grid
3+
* @return {number}
4+
*/
5+
var minimumArea = function (grid) {
6+
const [m, n] = [grid.length, grid[0].length];
7+
let [x1, y1] = [m, n];
8+
let [x2, y2] = [0, 0];
9+
for (let i = 0; i < m; ++i) {
10+
for (let j = 0; j < n; ++j) {
11+
if (grid[i][j] === 1) {
12+
x1 = Math.min(x1, i);
13+
y1 = Math.min(y1, j);
14+
x2 = Math.max(x2, i);
15+
y2 = Math.max(y2, j);
16+
}
17+
}
18+
}
19+
return (x2 - x1 + 1) * (y2 - y1 + 1);
20+
};

‎solution/3100-3199/3195.Find the Minimum Area to Cover All Ones I/Solution.rs

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
impl Solution {
2+
pub fn minimum_area(grid: Vec<Vec<i32>>) -> i32 {
3+
let m = grid.len();
4+
let n = grid[0].len();
5+
let mut x1 = m as i32;
6+
let mut y1 = n as i32;
7+
let mut x2 = 0i32;
8+
let mut y2 = 0i32;
9+
10+
for i in 0..m {
11+
for j in 0..n {
12+
if grid[i][j] == 1 {
13+
x1 = x1.min(i as i32);
14+
y1 = y1.min(j as i32);
15+
x2 = x2.max(i as i32);
16+
y2 = y2.max(j as i32);
17+
}
18+
}
19+
}
20+
21+
(x2 - x1 + 1) * (y2 - y1 + 1)
22+
}
23+
}

‎solution/3100-3199/3197.Find the Minimum Area to Cover All Ones II/README.md

Lines changed: 148 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -387,6 +387,154 @@ function minimumSum(grid: number[][]): number {
387387
}
388388
```
389389

390+
#### Rust
391+
392+
```rust
393+
impl Solution {
394+
pub fn minimum_sum(grid: Vec<Vec<i32>>) -> i32 {
395+
let m = grid.len();
396+
let n = grid[0].len();
397+
let mut ans = (m * n) as i32;
398+
let inf = i32::MAX / 4;
399+
400+
let f = |i1: usize, j1: usize, i2: usize, j2: usize| -> i32 {
401+
let mut x1 = inf;
402+
let mut y1 = inf;
403+
let mut x2 = -inf;
404+
let mut y2 = -inf;
405+
406+
for i in i1..=i2 {
407+
for j in j1..=j2 {
408+
if grid[i][j] == 1 {
409+
x1 = x1.min(i as i32);
410+
y1 = y1.min(j as i32);
411+
x2 = x2.max(i as i32);
412+
y2 = y2.max(j as i32);
413+
}
414+
}
415+
}
416+
if x1 > x2 || y1 > y2 {
417+
inf
418+
} else {
419+
(x2 - x1 + 1) * (y2 - y1 + 1)
420+
}
421+
};
422+
423+
for i1 in 0..m - 1 {
424+
for i2 in i1 + 1..m - 1 {
425+
ans = ans.min(
426+
f(0, 0, i1, n - 1)
427+
+ f(i1 + 1, 0, i2, n - 1)
428+
+ f(i2 + 1, 0, m - 1, n - 1),
429+
);
430+
}
431+
}
432+
433+
for j1 in 0..n - 1 {
434+
for j2 in j1 + 1..n - 1 {
435+
ans = ans.min(
436+
f(0, 0, m - 1, j1)
437+
+ f(0, j1 + 1, m - 1, j2)
438+
+ f(0, j2 + 1, m - 1, n - 1),
439+
);
440+
}
441+
}
442+
443+
for i in 0..m - 1 {
444+
for j in 0..n - 1 {
445+
ans = ans.min(
446+
f(0, 0, i, j)
447+
+ f(0, j + 1, i, n - 1)
448+
+ f(i + 1, 0, m - 1, n - 1),
449+
);
450+
ans = ans.min(
451+
f(0, 0, i, n - 1)
452+
+ f(i + 1, 0, m - 1, j)
453+
+ f(i + 1, j + 1, m - 1, n - 1),
454+
);
455+
ans = ans.min(
456+
f(0, 0, i, j)
457+
+ f(i + 1, 0, m - 1, j)
458+
+ f(0, j + 1, m - 1, n - 1),
459+
);
460+
ans = ans.min(
461+
f(0, 0, m - 1, j)
462+
+ f(0, j + 1, i, n - 1)
463+
+ f(i + 1, j + 1, m - 1, n - 1),
464+
);
465+
}
466+
}
467+
468+
ans
469+
}
470+
}
471+
```
472+
473+
#### JavaScript
474+
475+
```js
476+
/**
477+
* @param {number[][]} grid
478+
* @return {number}
479+
*/
480+
var minimumSum = function (grid) {
481+
const m = grid.length;
482+
const n = grid[0].length;
483+
let ans = m * n;
484+
const inf = Number.MAX_SAFE_INTEGER;
485+
const f = (i1, j1, i2, j2) => {
486+
let [x1, y1] = [inf, inf];
487+
let [x2, y2] = [-inf, -inf];
488+
for (let i = i1; i <= i2; i++) {
489+
for (let j = j1; j <= j2; j++) {
490+
if (grid[i][j] === 1) {
491+
x1 = Math.min(x1, i);
492+
y1 = Math.min(y1, j);
493+
x2 = Math.max(x2, i);
494+
y2 = Math.max(y2, j);
495+
}
496+
}
497+
}
498+
return x1 === inf ? 0 : (x2 - x1 + 1) * (y2 - y1 + 1);
499+
};
500+
501+
for (let i1 = 0; i1 < m - 1; i1++) {
502+
for (let i2 = i1 + 1; i2 < m - 1; i2++) {
503+
ans = Math.min(
504+
ans,
505+
f(0, 0, i1, n - 1) + f(i1 + 1, 0, i2, n - 1) + f(i2 + 1, 0, m - 1, n - 1),
506+
);
507+
}
508+
}
509+
510+
for (let j1 = 0; j1 < n - 1; j1++) {
511+
for (let j2 = j1 + 1; j2 < n - 1; j2++) {
512+
ans = Math.min(
513+
ans,
514+
f(0, 0, m - 1, j1) + f(0, j1 + 1, m - 1, j2) + f(0, j2 + 1, m - 1, n - 1),
515+
);
516+
}
517+
}
518+
519+
for (let i = 0; i < m - 1; i++) {
520+
for (let j = 0; j < n - 1; j++) {
521+
ans = Math.min(ans, f(0, 0, i, j) + f(0, j + 1, i, n - 1) + f(i + 1, 0, m - 1, n - 1));
522+
ans = Math.min(
523+
ans,
524+
f(0, 0, i, n - 1) + f(i + 1, 0, m - 1, j) + f(i + 1, j + 1, m - 1, n - 1),
525+
);
526+
ans = Math.min(ans, f(0, 0, i, j) + f(i + 1, 0, m - 1, j) + f(0, j + 1, m - 1, n - 1));
527+
ans = Math.min(
528+
ans,
529+
f(0, 0, m - 1, j) + f(0, j + 1, i, n - 1) + f(i + 1, j + 1, m - 1, n - 1),
530+
);
531+
}
532+
}
533+
534+
return ans;
535+
};
536+
```
537+
390538
<!-- tabs:end -->
391539

392540
<!-- solution:end -->

0 commit comments

Comments
 (0)