Skip to content

Commit 5a65b3f

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1139
No.1139.Largest 1-Bordered Square
1 parent 78a17b0 commit 5a65b3f

File tree

6 files changed

+339
-15
lines changed

6 files changed

+339
-15
lines changed

‎solution/1100-1199/1139.Largest 1-Bordered Square/README.md

Lines changed: 127 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -36,22 +36,148 @@
3636

3737
<!-- 这里可写通用的实现逻辑 -->
3838

39+
**方法一：前缀和 + 枚举**
40+
41+
我们可以使用前缀和的方法预处理出每个位置向下和向右的连续 $1$ 的个数，记为 `down[i][j]` 和 `right[i][j]`。
42+
43+
然后我们枚举正方形的边长 $k$，从最大的边长开始枚举，然后枚举正方形的左上角位置 $(i, j)$，如果满足条件，即可返回 $k^2$。
44+
45+
时间复杂度 $O(m \times n \times \min(m, n))$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别是网格的行数和列数。
46+
3947
<!-- tabs:start -->
4048

4149
### **Python3**
4250

4351
<!-- 这里可写当前语言的特殊实现逻辑 -->
4452

4553
```python
46-
54+
class Solution:
55+
def largest1BorderedSquare(self, grid: List[List[int]]) -> int:
56+
m, n = len(grid), len(grid[0])
57+
down = [[0] * n for _ in range(m)]
58+
right = [[0] * n for _ in range(m)]
59+
for i in range(m - 1, -1, -1):
60+
for j in range(n - 1, -1, -1):
61+
if grid[i][j]:
62+
down[i][j] = down[i + 1][j] + 1 if i + 1 < m else 1
63+
right[i][j] = right[i][j + 1] + 1 if j + 1 < n else 1
64+
for k in range(min(m, n), 0, -1):
65+
for i in range(m - k + 1):
66+
for j in range(n - k + 1):
67+
if down[i][j] >= k and right[i][j] >= k and right[i + k - 1][j] >= k and down[i][j + k - 1] >= k:
68+
return k * k
69+
return 0
4770
```
4871

4972
### **Java**
5073

5174
<!-- 这里可写当前语言的特殊实现逻辑 -->
5275

5376
```java
77+
class Solution {
78+
public int largest1BorderedSquare(int[][] grid) {
79+
int m = grid.length, n = grid[0].length;
80+
int[][] down = new int[m][n];
81+
int[][] right = new int[m][n];
82+
for (int i = m - 1; i >= 0; --i) {
83+
for (int j = n - 1; j >= 0; --j) {
84+
if (grid[i][j] == 1) {
85+
down[i][j] = i + 1 < m ? down[i + 1][j] + 1 : 1;
86+
right[i][j] = j + 1 < n ? right[i][j + 1] + 1 : 1;
87+
}
88+
}
89+
}
90+
for (int k = Math.min(m, n); k > 0; --k) {
91+
for (int i = 0; i <= m - k; ++i) {
92+
for (int j = 0; j <= n - k; ++j) {
93+
if (down[i][j] >= k && right[i][j] >= k && right[i + k - 1][j] >= k
94+
&& down[i][j + k - 1] >= k) {
95+
return k * k;
96+
}
97+
}
98+
}
99+
}
100+
return 0;
101+
}
102+
}
103+
```
104+
105+
### **C++**
106+
107+
```cpp
108+
class Solution {
109+
public:
110+
int largest1BorderedSquare(vector<vector<int>>& grid) {
111+
int m = grid.size(), n = grid[0].size();
112+
int down[m][n];
113+
int right[m][n];
114+
memset(down, 0, sizeof down);
115+
memset(right, 0, sizeof right);
116+
for (int i = m - 1; i >= 0; --i) {
117+
for (int j = n - 1; j >= 0; --j) {
118+
if (grid[i][j] == 1) {
119+
down[i][j] = i + 1 < m ? down[i + 1][j] + 1 : 1;
120+
right[i][j] = j + 1 < n ? right[i][j + 1] + 1 : 1;
121+
}
122+
}
123+
}
124+
for (int k = min(m, n); k > 0; --k) {
125+
for (int i = 0; i <= m - k; ++i) {
126+
for (int j = 0; j <= n - k; ++j) {
127+
if (down[i][j] >= k && right[i][j] >= k && right[i + k - 1][j] >= k
128+
&& down[i][j + k - 1] >= k) {
129+
return k * k;
130+
}
131+
}
132+
}
133+
}
134+
return 0;
135+
}
136+
};
137+
```
54138
139+
### **Go**
140+
141+
```go
142+
func largest1BorderedSquare(grid [][]int) int {
143+
m, n := len(grid), len(grid[0])
144+
down := make([][]int, m)
145+
right := make([][]int, m)
146+
for i := range down {
147+
down[i] = make([]int, n)
148+
right[i] = make([]int, n)
149+
}
150+
for i := m - 1; i >= 0; i-- {
151+
for j := n - 1; j >= 0; j-- {
152+
if grid[i][j] == 1 {
153+
down[i][j], right[i][j] = 1, 1
154+
if i+1 < m {
155+
down[i][j] += down[i+1][j]
156+
}
157+
if j+1 < n {
158+
right[i][j] += right[i][j+1]
159+
}
160+
}
161+
}
162+
}
163+
for k := min(m, n); k > 0; k-- {
164+
for i := 0; i <= m-k; i++ {
165+
for j := 0; j <= n-k; j++ {
166+
if down[i][j] >= k && right[i][j] >= k && right[i+k-1][j] >= k && down[i][j+k-1] >= k {
167+
return k * k
168+
}
169+
}
170+
}
171+
}
172+
return 0
173+
}
174+
175+
func min(a, b int) int {
176+
if a < b {
177+
return a
178+
}
179+
return b
180+
}
55181
```
56182

57183
### **...**

‎solution/1100-1199/1139.Largest 1-Bordered Square/README_EN.md

Lines changed: 119 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -33,13 +33,9 @@
3333
<p><strong>Constraints:</strong></p>
3434

3535
<ul>
36-
3736
<li><code>1 &lt;= grid.length &lt;= 100</code></li>
38-
3937
<li><code>1 &lt;= grid[0].length &lt;= 100</code></li>
40-
4138
<li><code>grid[i][j]</code> is <code>0</code> or <code>1</code></li>
42-
4339
</ul>
4440

4541
## Solutions
@@ -49,13 +45,131 @@
4945
### **Python3**
5046

5147
```python
52-
48+
class Solution:
49+
def largest1BorderedSquare(self, grid: List[List[int]]) -> int:
50+
m, n = len(grid), len(grid[0])
51+
down = [[0] * n for _ in range(m)]
52+
right = [[0] * n for _ in range(m)]
53+
for i in range(m - 1, -1, -1):
54+
for j in range(n - 1, -1, -1):
55+
if grid[i][j]:
56+
down[i][j] = down[i + 1][j] + 1 if i + 1 < m else 1
57+
right[i][j] = right[i][j + 1] + 1 if j + 1 < n else 1
58+
for k in range(min(m, n), 0, -1):
59+
for i in range(m - k + 1):
60+
for j in range(n - k + 1):
61+
if down[i][j] >= k and right[i][j] >= k and right[i + k - 1][j] >= k and down[i][j + k - 1] >= k:
62+
return k * k
63+
return 0
5364
```
5465

5566
### **Java**
5667

5768
```java
69+
class Solution {
70+
public int largest1BorderedSquare(int[][] grid) {
71+
int m = grid.length, n = grid[0].length;
72+
int[][] down = new int[m][n];
73+
int[][] right = new int[m][n];
74+
for (int i = m - 1; i >= 0; --i) {
75+
for (int j = n - 1; j >= 0; --j) {
76+
if (grid[i][j] == 1) {
77+
down[i][j] = i + 1 < m ? down[i + 1][j] + 1 : 1;
78+
right[i][j] = j + 1 < n ? right[i][j + 1] + 1 : 1;
79+
}
80+
}
81+
}
82+
for (int k = Math.min(m, n); k > 0; --k) {
83+
for (int i = 0; i <= m - k; ++i) {
84+
for (int j = 0; j <= n - k; ++j) {
85+
if (down[i][j] >= k && right[i][j] >= k && right[i + k - 1][j] >= k
86+
&& down[i][j + k - 1] >= k) {
87+
return k * k;
88+
}
89+
}
90+
}
91+
}
92+
return 0;
93+
}
94+
}
95+
```
96+
97+
### **C++**
98+
99+
```cpp
100+
class Solution {
101+
public:
102+
int largest1BorderedSquare(vector<vector<int>>& grid) {
103+
int m = grid.size(), n = grid[0].size();
104+
int down[m][n];
105+
int right[m][n];
106+
memset(down, 0, sizeof down);
107+
memset(right, 0, sizeof right);
108+
for (int i = m - 1; i >= 0; --i) {
109+
for (int j = n - 1; j >= 0; --j) {
110+
if (grid[i][j] == 1) {
111+
down[i][j] = i + 1 < m ? down[i + 1][j] + 1 : 1;
112+
right[i][j] = j + 1 < n ? right[i][j + 1] + 1 : 1;
113+
}
114+
}
115+
}
116+
for (int k = min(m, n); k > 0; --k) {
117+
for (int i = 0; i <= m - k; ++i) {
118+
for (int j = 0; j <= n - k; ++j) {
119+
if (down[i][j] >= k && right[i][j] >= k && right[i + k - 1][j] >= k
120+
&& down[i][j + k - 1] >= k) {
121+
return k * k;
122+
}
123+
}
124+
}
125+
}
126+
return 0;
127+
}
128+
};
129+
```
58130
131+
### **Go**
132+
133+
```go
134+
func largest1BorderedSquare(grid [][]int) int {
135+
m, n := len(grid), len(grid[0])
136+
down := make([][]int, m)
137+
right := make([][]int, m)
138+
for i := range down {
139+
down[i] = make([]int, n)
140+
right[i] = make([]int, n)
141+
}
142+
for i := m - 1; i >= 0; i-- {
143+
for j := n - 1; j >= 0; j-- {
144+
if grid[i][j] == 1 {
145+
down[i][j], right[i][j] = 1, 1
146+
if i+1 < m {
147+
down[i][j] += down[i+1][j]
148+
}
149+
if j+1 < n {
150+
right[i][j] += right[i][j+1]
151+
}
152+
}
153+
}
154+
}
155+
for k := min(m, n); k > 0; k-- {
156+
for i := 0; i <= m-k; i++ {
157+
for j := 0; j <= n-k; j++ {
158+
if down[i][j] >= k && right[i][j] >= k && right[i+k-1][j] >= k && down[i][j+k-1] >= k {
159+
return k * k
160+
}
161+
}
162+
}
163+
}
164+
return 0
165+
}
166+
167+
func min(a, b int) int {
168+
if a < b {
169+
return a
170+
}
171+
return b
172+
}
59173
```
60174

61175
### **...**

‎solution/1100-1199/1139.Largest 1-Bordered Square/Solution.cpp

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
class Solution {
2+
public:
3+
int largest1BorderedSquare(vector<vector<int>>& grid) {
4+
int m = grid.size(), n = grid[0].size();
5+
int down[m][n];
6+
int right[m][n];
7+
memset(down, 0, sizeof down);
8+
memset(right, 0, sizeof right);
9+
for (int i = m - 1; i >= 0; --i) {
10+
for (int j = n - 1; j >= 0; --j) {
11+
if (grid[i][j] == 1) {
12+
down[i][j] = i + 1 < m ? down[i + 1][j] + 1 : 1;
13+
right[i][j] = j + 1 < n ? right[i][j + 1] + 1 : 1;
14+
}
15+
}
16+
}
17+
for (int k = min(m, n); k > 0; --k) {
18+
for (int i = 0; i <= m - k; ++i) {
19+
for (int j = 0; j <= n - k; ++j) {
20+
if (down[i][j] >= k && right[i][j] >= k && right[i + k - 1][j] >= k
21+
&& down[i][j + k - 1] >= k) {
22+
return k * k;
23+
}
24+
}
25+
}
26+
}
27+
return 0;
28+
}
29+
};

‎solution/1100-1199/1139.Largest 1-Bordered Square/Solution.go

Lines changed: 39 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,39 @@
1+
func largest1BorderedSquare(grid [][]int) int {
2+
m, n := len(grid), len(grid[0])
3+
down := make([][]int, m)
4+
right := make([][]int, m)
5+
for i := range down {
6+
down[i] = make([]int, n)
7+
right[i] = make([]int, n)
8+
}
9+
for i := m - 1; i >= 0; i-- {
10+
for j := n - 1; j >= 0; j-- {
11+
if grid[i][j] == 1 {
12+
down[i][j], right[i][j] = 1, 1
13+
if i+1 < m {
14+
down[i][j] += down[i+1][j]
15+
}
16+
if j+1 < n {
17+
right[i][j] += right[i][j+1]
18+
}
19+
}
20+
}
21+
}
22+
for k := min(m, n); k > 0; k-- {
23+
for i := 0; i <= m-k; i++ {
24+
for j := 0; j <= n-k; j++ {
25+
if down[i][j] >= k && right[i][j] >= k && right[i+k-1][j] >= k && down[i][j+k-1] >= k {
26+
return k * k
27+
}
28+
}
29+
}
30+
}
31+
return 0
32+
}
33+
34+
func min(a, b int) int {
35+
if a < b {
36+
return a
37+
}
38+
return b
39+
}

0 commit comments

Comments
 (0)