Skip to content

Commit 83a8a90

Browse files
yanglbmeyanglbme
authored
feat: add solutions for lc No.1727 (#5075)
1 parent 910f74e commit 83a8a90

5 files changed

Lines changed: 205 additions & 71 deletions

File tree

‎solution/1700-1799/1727.Largest Submatrix With Rearrangements/README.md‎

Lines changed: 71 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -190,40 +190,88 @@ func largestSubmatrix(matrix [][]int) int {
190190

191191
```ts
192192
function largestSubmatrix(matrix: number[][]): number {
193-
for (let column = 0; column < matrix[0].length; column++) {
194-
for (let row = 0; row < matrix.length; row++) {
195-
let tempRow = row;
196-
let count = 0;
197-
198-
while (tempRow < matrix.length && matrix[tempRow][column] === 1) {
199-
count++;
200-
tempRow++;
201-
}
193+
const m: number = matrix.length;
194+
const n: number = matrix[0].length;
202195

203-
while (count !== 0) {
204-
matrix[row][column] = count;
205-
count--;
206-
row++;
196+
for (let i: number = 1; i < m; ++i) {
197+
for (let j: number = 0; j < n; ++j) {
198+
if (matrix[i][j] !== 0) {
199+
matrix[i][j] = matrix[i - 1][j] + 1;
207200
}
208201
}
209202
}
210203

211-
for (let row = 0; row < matrix.length; row++) {
212-
matrix[row].sort((a, b) => a - b);
204+
let ans: number = 0;
205+
206+
for (const row of matrix) {
207+
row.sort((a, b) => b - a);
208+
for (let j: number = 0; j < n; ++j) {
209+
ans = Math.max(ans, (j + 1) * row[j]);
210+
}
213211
}
214212

215-
let maxSubmatrixArea = 0;
213+
return ans;
214+
}
215+
```
216216

217-
for (let row = 0; row < matrix.length; row++) {
218-
for (let col = matrix[row].length - 1; col >= 0; col--) {
219-
maxSubmatrixArea = Math.max(
220-
maxSubmatrixArea,
221-
matrix[row][col] * (matrix[row].length - col),
222-
);
217+
#### Rust
218+
219+
```rust
220+
impl Solution {
221+
pub fn largest_submatrix(mut matrix: Vec<Vec<i32>>) -> i32 {
222+
let m: usize = matrix.len();
223+
let n: usize = matrix[0].len();
224+
225+
for i in 1..m {
226+
for j in 0..n {
227+
if matrix[i][j] != 0 {
228+
matrix[i][j] = matrix[i - 1][j] + 1;
229+
}
230+
}
231+
}
232+
233+
let mut ans: i32 = 0;
234+
235+
for row in matrix.iter_mut() {
236+
row.sort_unstable_by(|a, b| b.cmp(a));
237+
for j in 0..n {
238+
ans = ans.max((j as i32 + 1) * row[j]);
239+
}
223240
}
241+
242+
ans
224243
}
244+
}
245+
```
225246

226-
return maxSubmatrixArea;
247+
#### C#
248+
249+
```cs
250+
public class Solution {
251+
public int LargestSubmatrix(int[][] matrix) {
252+
int m = matrix.Length;
253+
int n = matrix[0].Length;
254+
255+
for (int i = 1; i < m; ++i) {
256+
for (int j = 0; j < n; ++j) {
257+
if (matrix[i][j] != 0) {
258+
matrix[i][j] = matrix[i - 1][j] + 1;
259+
}
260+
}
261+
}
262+
263+
int ans = 0;
264+
265+
foreach (var row in matrix) {
266+
Array.Sort(row);
267+
Array.Reverse(row);
268+
for (int j = 0; j < n; ++j) {
269+
ans = Math.Max(ans, (j + 1) * row[j]);
270+
}
271+
}
272+
273+
return ans;
274+
}
227275
}
228276
```
229277

‎solution/1700-1799/1727.Largest Submatrix With Rearrangements/README_EN.md‎

Lines changed: 71 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -178,40 +178,88 @@ func largestSubmatrix(matrix [][]int) int {
178178

179179
```ts
180180
function largestSubmatrix(matrix: number[][]): number {
181-
for (let column = 0; column < matrix[0].length; column++) {
182-
for (let row = 0; row < matrix.length; row++) {
183-
let tempRow = row;
184-
let count = 0;
185-
186-
while (tempRow < matrix.length && matrix[tempRow][column] === 1) {
187-
count++;
188-
tempRow++;
189-
}
181+
const m: number = matrix.length;
182+
const n: number = matrix[0].length;
190183

191-
while (count !== 0) {
192-
matrix[row][column] = count;
193-
count--;
194-
row++;
184+
for (let i: number = 1; i < m; ++i) {
185+
for (let j: number = 0; j < n; ++j) {
186+
if (matrix[i][j] !== 0) {
187+
matrix[i][j] = matrix[i - 1][j] + 1;
195188
}
196189
}
197190
}
198191

199-
for (let row = 0; row < matrix.length; row++) {
200-
matrix[row].sort((a, b) => a - b);
192+
let ans: number = 0;
193+
194+
for (const row of matrix) {
195+
row.sort((a, b) => b - a);
196+
for (let j: number = 0; j < n; ++j) {
197+
ans = Math.max(ans, (j + 1) * row[j]);
198+
}
201199
}
202200

203-
let maxSubmatrixArea = 0;
201+
return ans;
202+
}
203+
```
204204

205-
for (let row = 0; row < matrix.length; row++) {
206-
for (let col = matrix[row].length - 1; col >= 0; col--) {
207-
maxSubmatrixArea = Math.max(
208-
maxSubmatrixArea,
209-
matrix[row][col] * (matrix[row].length - col),
210-
);
205+
#### Rust
206+
207+
```rust
208+
impl Solution {
209+
pub fn largest_submatrix(mut matrix: Vec<Vec<i32>>) -> i32 {
210+
let m: usize = matrix.len();
211+
let n: usize = matrix[0].len();
212+
213+
for i in 1..m {
214+
for j in 0..n {
215+
if matrix[i][j] != 0 {
216+
matrix[i][j] = matrix[i - 1][j] + 1;
217+
}
218+
}
219+
}
220+
221+
let mut ans: i32 = 0;
222+
223+
for row in matrix.iter_mut() {
224+
row.sort_unstable_by(|a, b| b.cmp(a));
225+
for j in 0..n {
226+
ans = ans.max((j as i32 + 1) * row[j]);
227+
}
211228
}
229+
230+
ans
212231
}
232+
}
233+
```
213234

214-
return maxSubmatrixArea;
235+
#### C#
236+
237+
```cs
238+
public class Solution {
239+
public int LargestSubmatrix(int[][] matrix) {
240+
int m = matrix.Length;
241+
int n = matrix[0].Length;
242+
243+
for (int i = 1; i < m; ++i) {
244+
for (int j = 0; j < n; ++j) {
245+
if (matrix[i][j] != 0) {
246+
matrix[i][j] = matrix[i - 1][j] + 1;
247+
}
248+
}
249+
}
250+
251+
int ans = 0;
252+
253+
foreach (var row in matrix) {
254+
Array.Sort(row);
255+
Array.Reverse(row);
256+
for (int j = 0; j < n; ++j) {
257+
ans = Math.Max(ans, (j + 1) * row[j]);
258+
}
259+
}
260+
261+
return ans;
262+
}
215263
}
216264
```
217265

‎solution/1700-1799/1727.Largest Submatrix With Rearrangements/Solution.cs‎

Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
public class Solution {
2+
public int LargestSubmatrix(int[][] matrix) {
3+
int m = matrix.Length;
4+
int n = matrix[0].Length;
5+
6+
for (int i = 1; i < m; ++i) {
7+
for (int j = 0; j < n; ++j) {
8+
if (matrix[i][j] != 0) {
9+
matrix[i][j] = matrix[i - 1][j] + 1;
10+
}
11+
}
12+
}
13+
14+
int ans = 0;
15+
16+
foreach (var row in matrix) {
17+
Array.Sort(row);
18+
Array.Reverse(row);
19+
for (int j = 0; j < n; ++j) {
20+
ans = Math.Max(ans, (j + 1) * row[j]);
21+
}
22+
}
23+
24+
return ans;
25+
}
26+
}

‎solution/1700-1799/1727.Largest Submatrix With Rearrangements/Solution.rs‎

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
impl Solution {
2+
pub fn largest_submatrix(mut matrix: Vec<Vec<i32>>) -> i32 {
3+
let m: usize = matrix.len();
4+
let n: usize = matrix[0].len();
5+
6+
for i in 1..m {
7+
for j in 0..n {
8+
if matrix[i][j] != 0 {
9+
matrix[i][j] = matrix[i - 1][j] + 1;
10+
}
11+
}
12+
}
13+
14+
let mut ans: i32 = 0;
15+
16+
for row in matrix.iter_mut() {
17+
row.sort_unstable_by(|a, b| b.cmp(a));
18+
for j in 0..n {
19+
ans = ans.max((j as i32 + 1) * row[j]);
20+
}
21+
}
22+
23+
ans
24+
}
25+
}

‎solution/1700-1799/1727.Largest Submatrix With Rearrangements/Solution.ts‎

Lines changed: 12 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -1,36 +1,23 @@
11
function largestSubmatrix(matrix: number[][]): number {
2-
for (let column = 0; column < matrix[0].length; column++) {
3-
for (let row = 0; row < matrix.length; row++) {
4-
let tempRow = row;
5-
let count = 0;
2+
const m: number = matrix.length;
3+
const n: number = matrix[0].length;
64

7-
while (tempRow < matrix.length && matrix[tempRow][column] === 1) {
8-
count++;
9-
tempRow++;
10-
}
11-
12-
while (count !== 0) {
13-
matrix[row][column] = count;
14-
count--;
15-
row++;
5+
for (let i: number = 1; i < m; ++i) {
6+
for (let j: number = 0; j < n; ++j) {
7+
if (matrix[i][j] !== 0) {
8+
matrix[i][j] = matrix[i - 1][j] + 1;
169
}
1710
}
1811
}
1912

20-
for (let row = 0; row < matrix.length; row++) {
21-
matrix[row].sort((a, b) => a - b);
22-
}
23-
24-
let maxSubmatrixArea = 0;
13+
let ans: number = 0;
2514

26-
for (let row = 0; row < matrix.length; row++) {
27-
for (let col = matrix[row].length - 1; col >= 0; col--) {
28-
maxSubmatrixArea = Math.max(
29-
maxSubmatrixArea,
30-
matrix[row][col] * (matrix[row].length - col),
31-
);
15+
for (const row of matrix) {
16+
row.sort((a, b) => b - a);
17+
for (let j: number = 0; j < n; ++j) {
18+
ans = Math.max(ans, (j + 1) * row[j]);
3219
}
3320
}
3421

35-
return maxSubmatrixArea;
22+
return ans;
3623
}

0 commit comments

Comments
 (0)