Skip to content

Commit 5d6ca31

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0764
No.0764.Largest Plus Sign
1 parent 498dcb2 commit 5d6ca31

File tree

6 files changed

+395
-2
lines changed

6 files changed

+395
-2
lines changed

‎solution/0700-0799/0764.Largest Plus Sign/README.md

Lines changed: 140 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -49,22 +49,161 @@
4949

5050
<!-- 这里可写通用的实现逻辑 -->
5151

52+
**方法一：动态规划**
53+
54+
我们定义 $dp[i][j]$ 表示以 $(i, j)$ 为中心的最大加号标志的阶数，答案即为所有 $dp[i][j]$ 的最大值。
55+
56+
我们可以发现，对于每个 $(i, j)$，其最大加号标志的阶数不会超过其上下左右四个方向上连续的 $1$ 的个数的最小值。因此，我们可以预处理出每个位置上下左右四个方向上连续的 $1$ 的个数，然后遍历所有的 $(i, j)$，求出 $dp[i][j]$ 的最大值即可。
57+
58+
时间复杂度 $O(n^2)$，空间复杂度 $O(n^2)$。其中 $n$ 为网格的边长。
59+
5260
<!-- tabs:start -->
5361

5462
### **Python3**
5563

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

5866
```python
59-
67+
class Solution:
68+
def orderOfLargestPlusSign(self, n: int, mines: List[List[int]]) -> int:
69+
dp = [[n] * n for _ in range(n)]
70+
for x, y in mines:
71+
dp[x][y] = 0
72+
for i in range(n):
73+
left = right = up = down = 0
74+
for j, k in zip(range(n), reversed(range(n))):
75+
left = left + 1 if dp[i][j] else 0
76+
right = right + 1 if dp[i][k] else 0
77+
up = up + 1 if dp[j][i] else 0
78+
down = down + 1 if dp[k][i] else 0
79+
dp[i][j] = min(dp[i][j], left)
80+
dp[i][k] = min(dp[i][k], right)
81+
dp[j][i] = min(dp[j][i], up)
82+
dp[k][i] = min(dp[k][i], down)
83+
return max(max(v) for v in dp)
6084
```
6185

6286
### **Java**
6387

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

6690
```java
91+
class Solution {
92+
public int orderOfLargestPlusSign(int n, int[][] mines) {
93+
int[][] dp = new int[n][n];
94+
for (var e : dp) {
95+
Arrays.fill(e, n);
96+
}
97+
for (var e : mines) {
98+
dp[e[0]][e[1]] = 0;
99+
}
100+
for (int i = 0; i < n; ++i) {
101+
int left = 0, right = 0, up = 0, down = 0;
102+
for (int j = 0, k = n - 1; j < n; ++j, --k) {
103+
left = dp[i][j] > 0 ? left + 1 : 0;
104+
right = dp[i][k] > 0 ? right + 1 : 0;
105+
up = dp[j][i] > 0 ? up + 1 : 0;
106+
down = dp[k][i] > 0 ? down + 1 : 0;
107+
dp[i][j] = Math.min(dp[i][j], left);
108+
dp[i][k] = Math.min(dp[i][k], right);
109+
dp[j][i] = Math.min(dp[j][i], up);
110+
dp[k][i] = Math.min(dp[k][i], down);
111+
}
112+
}
113+
int ans = 0;
114+
for (var e : dp) {
115+
ans = Math.max(ans, Arrays.stream(e).max().getAsInt());
116+
}
117+
return ans;
118+
}
119+
}
120+
```
121+
122+
### **C++**
123+
124+
```cpp
125+
class Solution {
126+
public:
127+
int orderOfLargestPlusSign(int n, vector<vector<int>>& mines) {
128+
vector<vector<int>> dp(n, vector<int>(n, n));
129+
for (auto& e : mines) dp[e[0]][e[1]] = 0;
130+
for (int i = 0; i < n; ++i) {
131+
int left = 0, right = 0, up = 0, down = 0;
132+
for (int j = 0, k = n - 1; j < n; ++j, --k) {
133+
left = dp[i][j] ? left + 1 : 0;
134+
right = dp[i][k] ? right + 1 : 0;
135+
up = dp[j][i] ? up + 1 : 0;
136+
down = dp[k][i] ? down + 1 : 0;
137+
dp[i][j] = min(dp[i][j], left);
138+
dp[i][k] = min(dp[i][k], right);
139+
dp[j][i] = min(dp[j][i], up);
140+
dp[k][i] = min(dp[k][i], down);
141+
}
142+
}
143+
int ans = 0;
144+
for (auto& e : dp) ans = max(ans, *max_element(e.begin(), e.end()));
145+
return ans;
146+
}
147+
};
148+
```
67149
150+
### **Go**
151+
152+
```go
153+
func orderOfLargestPlusSign(n int, mines [][]int) (ans int) {
154+
dp := make([][]int, n)
155+
for i := range dp {
156+
dp[i] = make([]int, n)
157+
for j := range dp[i] {
158+
dp[i][j] = n
159+
}
160+
}
161+
for _, e := range mines {
162+
dp[e[0]][e[1]] = 0
163+
}
164+
for i := 0; i < n; i++ {
165+
var left, right, up, down int
166+
for j, k := 0, n-1; j < n; j, k = j+1, k-1 {
167+
left, right, up, down = left+1, right+1, up+1, down+1
168+
if dp[i][j] == 0 {
169+
left = 0
170+
}
171+
if dp[i][k] == 0 {
172+
right = 0
173+
}
174+
if dp[j][i] == 0 {
175+
up = 0
176+
}
177+
if dp[k][i] == 0 {
178+
down = 0
179+
}
180+
dp[i][j] = min(dp[i][j], left)
181+
dp[i][k] = min(dp[i][k], right)
182+
dp[j][i] = min(dp[j][i], up)
183+
dp[k][i] = min(dp[k][i], down)
184+
}
185+
}
186+
for _, e := range dp {
187+
for _, v := range e {
188+
ans = max(ans, v)
189+
}
190+
}
191+
return
192+
}
193+
194+
func min(a, b int) int {
195+
if a < b {
196+
return a
197+
}
198+
return b
199+
}
200+
201+
func max(a, b int) int {
202+
if a > b {
203+
return a
204+
}
205+
return b
206+
}
68207
```
69208

70209
### **...**

‎solution/0700-0799/0764.Largest Plus Sign/README_EN.md

Lines changed: 132 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -44,13 +44,144 @@
4444
### **Python3**
4545

4646
```python
47-
47+
class Solution:
48+
def orderOfLargestPlusSign(self, n: int, mines: List[List[int]]) -> int:
49+
dp = [[n] * n for _ in range(n)]
50+
for x, y in mines:
51+
dp[x][y] = 0
52+
for i in range(n):
53+
left = right = up = down = 0
54+
for j, k in zip(range(n), reversed(range(n))):
55+
left = left + 1 if dp[i][j] else 0
56+
right = right + 1 if dp[i][k] else 0
57+
up = up + 1 if dp[j][i] else 0
58+
down = down + 1 if dp[k][i] else 0
59+
dp[i][j] = min(dp[i][j], left)
60+
dp[i][k] = min(dp[i][k], right)
61+
dp[j][i] = min(dp[j][i], up)
62+
dp[k][i] = min(dp[k][i], down)
63+
return max(max(v) for v in dp)
4864
```
4965

5066
### **Java**
5167

5268
```java
69+
class Solution {
70+
public int orderOfLargestPlusSign(int n, int[][] mines) {
71+
int[][] dp = new int[n][n];
72+
for (var e : dp) {
73+
Arrays.fill(e, n);
74+
}
75+
for (var e : mines) {
76+
dp[e[0]][e[1]] = 0;
77+
}
78+
for (int i = 0; i < n; ++i) {
79+
int left = 0, right = 0, up = 0, down = 0;
80+
for (int j = 0, k = n - 1; j < n; ++j, --k) {
81+
left = dp[i][j] > 0 ? left + 1 : 0;
82+
right = dp[i][k] > 0 ? right + 1 : 0;
83+
up = dp[j][i] > 0 ? up + 1 : 0;
84+
down = dp[k][i] > 0 ? down + 1 : 0;
85+
dp[i][j] = Math.min(dp[i][j], left);
86+
dp[i][k] = Math.min(dp[i][k], right);
87+
dp[j][i] = Math.min(dp[j][i], up);
88+
dp[k][i] = Math.min(dp[k][i], down);
89+
}
90+
}
91+
int ans = 0;
92+
for (var e : dp) {
93+
ans = Math.max(ans, Arrays.stream(e).max().getAsInt());
94+
}
95+
return ans;
96+
}
97+
}
98+
```
99+
100+
### **C++**
101+
102+
```cpp
103+
class Solution {
104+
public:
105+
int orderOfLargestPlusSign(int n, vector<vector<int>>& mines) {
106+
vector<vector<int>> dp(n, vector<int>(n, n));
107+
for (auto& e : mines) dp[e[0]][e[1]] = 0;
108+
for (int i = 0; i < n; ++i) {
109+
int left = 0, right = 0, up = 0, down = 0;
110+
for (int j = 0, k = n - 1; j < n; ++j, --k) {
111+
left = dp[i][j] ? left + 1 : 0;
112+
right = dp[i][k] ? right + 1 : 0;
113+
up = dp[j][i] ? up + 1 : 0;
114+
down = dp[k][i] ? down + 1 : 0;
115+
dp[i][j] = min(dp[i][j], left);
116+
dp[i][k] = min(dp[i][k], right);
117+
dp[j][i] = min(dp[j][i], up);
118+
dp[k][i] = min(dp[k][i], down);
119+
}
120+
}
121+
int ans = 0;
122+
for (auto& e : dp) ans = max(ans, *max_element(e.begin(), e.end()));
123+
return ans;
124+
}
125+
};
126+
```
53127
128+
### **Go**
129+
130+
```go
131+
func orderOfLargestPlusSign(n int, mines [][]int) (ans int) {
132+
dp := make([][]int, n)
133+
for i := range dp {
134+
dp[i] = make([]int, n)
135+
for j := range dp[i] {
136+
dp[i][j] = n
137+
}
138+
}
139+
for _, e := range mines {
140+
dp[e[0]][e[1]] = 0
141+
}
142+
for i := 0; i < n; i++ {
143+
var left, right, up, down int
144+
for j, k := 0, n-1; j < n; j, k = j+1, k-1 {
145+
left, right, up, down = left+1, right+1, up+1, down+1
146+
if dp[i][j] == 0 {
147+
left = 0
148+
}
149+
if dp[i][k] == 0 {
150+
right = 0
151+
}
152+
if dp[j][i] == 0 {
153+
up = 0
154+
}
155+
if dp[k][i] == 0 {
156+
down = 0
157+
}
158+
dp[i][j] = min(dp[i][j], left)
159+
dp[i][k] = min(dp[i][k], right)
160+
dp[j][i] = min(dp[j][i], up)
161+
dp[k][i] = min(dp[k][i], down)
162+
}
163+
}
164+
for _, e := range dp {
165+
for _, v := range e {
166+
ans = max(ans, v)
167+
}
168+
}
169+
return
170+
}
171+
172+
func min(a, b int) int {
173+
if a < b {
174+
return a
175+
}
176+
return b
177+
}
178+
179+
func max(a, b int) int {
180+
if a > b {
181+
return a
182+
}
183+
return b
184+
}
54185
```
55186

56187
### **...**

‎solution/0700-0799/0764.Largest Plus Sign/Solution.cpp

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
class Solution {
2+
public:
3+
int orderOfLargestPlusSign(int n, vector<vector<int>>& mines) {
4+
vector<vector<int>> dp(n, vector<int>(n, n));
5+
for (auto& e : mines) dp[e[0]][e[1]] = 0;
6+
for (int i = 0; i < n; ++i) {
7+
int left = 0, right = 0, up = 0, down = 0;
8+
for (int j = 0, k = n - 1; j < n; ++j, --k) {
9+
left = dp[i][j] ? left + 1 : 0;
10+
right = dp[i][k] ? right + 1 : 0;
11+
up = dp[j][i] ? up + 1 : 0;
12+
down = dp[k][i] ? down + 1 : 0;
13+
dp[i][j] = min(dp[i][j], left);
14+
dp[i][k] = min(dp[i][k], right);
15+
dp[j][i] = min(dp[j][i], up);
16+
dp[k][i] = min(dp[k][i], down);
17+
}
18+
}
19+
int ans = 0;
20+
for (auto& e : dp) ans = max(ans, *max_element(e.begin(), e.end()));
21+
return ans;
22+
}
23+
};

‎solution/0700-0799/0764.Largest Plus Sign/Solution.go

Lines changed: 54 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,54 @@
1+
func orderOfLargestPlusSign(n int, mines [][]int) (ans int) {
2+
dp := make([][]int, n)
3+
for i := range dp {
4+
dp[i] = make([]int, n)
5+
for j := range dp[i] {
6+
dp[i][j] = n
7+
}
8+
}
9+
for _, e := range mines {
10+
dp[e[0]][e[1]] = 0
11+
}
12+
for i := 0; i < n; i++ {
13+
var left, right, up, down int
14+
for j, k := 0, n-1; j < n; j, k = j+1, k-1 {
15+
left, right, up, down = left+1, right+1, up+1, down+1
16+
if dp[i][j] == 0 {
17+
left = 0
18+
}
19+
if dp[i][k] == 0 {
20+
right = 0
21+
}
22+
if dp[j][i] == 0 {
23+
up = 0
24+
}
25+
if dp[k][i] == 0 {
26+
down = 0
27+
}
28+
dp[i][j] = min(dp[i][j], left)
29+
dp[i][k] = min(dp[i][k], right)
30+
dp[j][i] = min(dp[j][i], up)
31+
dp[k][i] = min(dp[k][i], down)
32+
}
33+
}
34+
for _, e := range dp {
35+
for _, v := range e {
36+
ans = max(ans, v)
37+
}
38+
}
39+
return
40+
}
41+
42+
func min(a, b int) int {
43+
if a < b {
44+
return a
45+
}
46+
return b
47+
}
48+
49+
func max(a, b int) int {
50+
if a > b {
51+
return a
52+
}
53+
return b
54+
}

0 commit comments

Comments
 (0)