Skip to content

Commit 06bd2ee

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.2088
No.2088.Count Fertile Pyramids in a Land
1 parent ce92c8c commit 06bd2ee

File tree

6 files changed

+424
-2
lines changed

6 files changed

+424
-2
lines changed

‎solution/2000-2099/2088.Count Fertile Pyramids in a Land/README.md

Lines changed: 159 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -91,22 +91,180 @@
9191

9292
<!-- 这里可写通用的实现逻辑 -->
9393

94+
**方法一：动态规划**
95+
96+
我们定义 $f[i][j]$ 表示以 $(i, j)$ 为顶点的金字塔的最大高度，那么有如下状态转移方程：
97+
98+
$$
99+
f[i][j] = \begin{cases} 0 & \text{grid}[i][j] = 0 \\ \min(f[i + 1][j - 1], f[i + 1][j], f[i + 1][j + 1]) + 1 & \text{grid}[i][j] = 1 \end{cases}
100+
$$
101+
102+
因此，我们可以从下往上、从左往右遍历网格，计算出所有的 $f[i][j]$，并累加所有的 $f[i][j]$ 即可得到正金字塔的个数。
103+
104+
接下来，我们考虑倒金字塔的个数。与金字塔类似，我们定义 $g[i][j]$ 表示以 $(i, j)$ 为顶点的倒金字塔的最大高度，那么有如下状态转移方程：
105+
106+
$$
107+
g[i][j] = \begin{cases} 0 & \text{grid}[i][j] = 0 \\ \min(g[i - 1][j - 1], g[i - 1][j], g[i - 1][j + 1]) + 1 & \text{grid}[i][j] = 1 \end{cases}
108+
$$
109+
110+
因此，我们可以从上往下、从左往右遍历网格，计算出所有的 $g[i][j]$，并累加所有的 $g[i][j]$ 即可得到倒金字塔的个数。
111+
112+
最后，正金字塔的个数加上倒金字塔的个数即为答案。实际代码中，我们可以只用一个二维数组 $f[i][j]$ 即可。
113+
114+
时间复杂度 $O(m \times n)$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别为网格的行数和列数。
115+
94116
<!-- tabs:start -->
95117

96118
### **Python3**
97119

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

100122
```python
101-
123+
class Solution:
124+
def countPyramids(self, grid: List[List[int]]) -> int:
125+
m, n = len(grid), len(grid[0])
126+
f = [[0] * n for _ in range(m)]
127+
ans = 0
128+
for i in range(m - 1, -1, -1):
129+
for j in range(n):
130+
if grid[i][j] == 0:
131+
f[i][j] = -1
132+
elif not (i == m - 1 or j == 0 or j == n - 1):
133+
f[i][j] = min(f[i + 1][j - 1], f[i + 1]
134+
[j], f[i + 1][j + 1]) + 1
135+
ans += f[i][j]
136+
for i in range(m):
137+
for j in range(n):
138+
if grid[i][j] == 0:
139+
f[i][j] = -1
140+
elif i == 0 or j == 0 or j == n - 1:
141+
f[i][j] = 0
142+
else:
143+
f[i][j] = min(f[i - 1][j - 1], f[i - 1]
144+
[j], f[i - 1][j + 1]) + 1
145+
ans += f[i][j]
146+
return ans
102147
```
103148

104149
### **Java**
105150

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

108153
```java
154+
class Solution {
155+
public int countPyramids(int[][] grid) {
156+
int m = grid.length, n = grid[0].length;
157+
int[][] f = new int[m][n];
158+
int ans = 0;
159+
for (int i = m - 1; i >= 0; --i) {
160+
for (int j = 0; j < n; ++j) {
161+
if (grid[i][j] == 0) {
162+
f[i][j] = -1;
163+
} else if (i == m - 1 || j == 0 || j == n - 1) {
164+
f[i][j] = 0;
165+
} else {
166+
f[i][j] = Math.min(f[i + 1][j - 1], Math.min(f[i + 1][j], f[i + 1][j + 1])) + 1;
167+
ans += f[i][j];
168+
}
169+
}
170+
}
171+
for (int i = 0; i < m; ++i) {
172+
for (int j = 0; j < n; ++j) {
173+
if (grid[i][j] == 0) {
174+
f[i][j] = -1;
175+
} else if (i == 0 || j == 0 || j == n - 1) {
176+
f[i][j] = 0;
177+
} else {
178+
f[i][j] = Math.min(f[i - 1][j - 1], Math.min(f[i - 1][j], f[i - 1][j + 1])) + 1;
179+
ans += f[i][j];
180+
}
181+
}
182+
}
183+
return ans;
184+
}
185+
}
186+
```
187+
188+
### **C++**
189+
190+
```cpp
191+
class Solution {
192+
public:
193+
int countPyramids(vector<vector<int>>& grid) {
194+
int m = grid.size(), n = grid[0].size();
195+
int f[m][n];
196+
int ans = 0;
197+
for (int i = m - 1; ~i; --i) {
198+
for (int j = 0; j < n; ++j) {
199+
if (grid[i][j] == 0) {
200+
f[i][j] = -1;
201+
} else if (i == m - 1 || j == 0 || j == n - 1) {
202+
f[i][j] = 0;
203+
} else {
204+
f[i][j] = min({f[i + 1][j - 1], f[i + 1][j], f[i + 1][j + 1]}) + 1;
205+
ans += f[i][j];
206+
}
207+
}
208+
}
209+
for (int i = 0; i < m; ++i) {
210+
for (int j = 0; j < n; ++j) {
211+
if (grid[i][j] == 0) {
212+
f[i][j] = -1;
213+
} else if (i == 0 || j == 0 || j == n - 1) {
214+
f[i][j] = 0;
215+
} else {
216+
f[i][j] = min({f[i - 1][j - 1], f[i - 1][j], f[i - 1][j + 1]}) + 1;
217+
ans += f[i][j];
218+
}
219+
}
220+
}
221+
return ans;
222+
}
223+
};
224+
```
109225
226+
### **Go**
227+
228+
```go
229+
func countPyramids(grid [][]int) (ans int) {
230+
m, n := len(grid), len(grid[0])
231+
f := make([][]int, m)
232+
for i := range f {
233+
f[i] = make([]int, n)
234+
}
235+
for i := m - 1; i >= 0; i-- {
236+
for j := 0; j < n; j++ {
237+
if grid[i][j] == 0 {
238+
f[i][j] = -1
239+
} else if i == m-1 || j == 0 || j == n-1 {
240+
f[i][j] = 0
241+
} else {
242+
f[i][j] = min(f[i+1][j-1], min(f[i+1][j], f[i+1][j+1])) + 1
243+
ans += f[i][j]
244+
}
245+
}
246+
}
247+
for i := 0; i < m; i++ {
248+
for j := 0; j < n; j++ {
249+
if grid[i][j] == 0 {
250+
f[i][j] = -1
251+
} else if i == 0 || j == 0 || j == n-1 {
252+
f[i][j] = 0
253+
} else {
254+
f[i][j] = min(f[i-1][j-1], min(f[i-1][j], f[i-1][j+1])) + 1
255+
ans += f[i][j]
256+
}
257+
}
258+
}
259+
return
260+
}
261+
262+
func min(a, b int) int {
263+
if a < b {
264+
return a
265+
}
266+
return b
267+
}
110268
```
111269

112270
### **...**

‎solution/2000-2099/2088.Count Fertile Pyramids in a Land/README_EN.md

Lines changed: 137 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -72,13 +72,149 @@ The total number of plots is 7 + 6 = 13.
7272
### **Python3**
7373

7474
```python
75-
75+
class Solution:
76+
def countPyramids(self, grid: List[List[int]]) -> int:
77+
m, n = len(grid), len(grid[0])
78+
f = [[0] * n for _ in range(m)]
79+
ans = 0
80+
for i in range(m - 1, -1, -1):
81+
for j in range(n):
82+
if grid[i][j] == 0:
83+
f[i][j] = -1
84+
elif not (i == m - 1 or j == 0 or j == n - 1):
85+
f[i][j] = min(f[i + 1][j - 1], f[i + 1]
86+
[j], f[i + 1][j + 1]) + 1
87+
ans += f[i][j]
88+
for i in range(m):
89+
for j in range(n):
90+
if grid[i][j] == 0:
91+
f[i][j] = -1
92+
elif i == 0 or j == 0 or j == n - 1:
93+
f[i][j] = 0
94+
else:
95+
f[i][j] = min(f[i - 1][j - 1], f[i - 1]
96+
[j], f[i - 1][j + 1]) + 1
97+
ans += f[i][j]
98+
return ans
7699
```
77100

78101
### **Java**
79102

80103
```java
104+
class Solution {
105+
public int countPyramids(int[][] grid) {
106+
int m = grid.length, n = grid[0].length;
107+
int[][] f = new int[m][n];
108+
int ans = 0;
109+
for (int i = m - 1; i >= 0; --i) {
110+
for (int j = 0; j < n; ++j) {
111+
if (grid[i][j] == 0) {
112+
f[i][j] = -1;
113+
} else if (i == m - 1 || j == 0 || j == n - 1) {
114+
f[i][j] = 0;
115+
} else {
116+
f[i][j] = Math.min(f[i + 1][j - 1], Math.min(f[i + 1][j], f[i + 1][j + 1])) + 1;
117+
ans += f[i][j];
118+
}
119+
}
120+
}
121+
for (int i = 0; i < m; ++i) {
122+
for (int j = 0; j < n; ++j) {
123+
if (grid[i][j] == 0) {
124+
f[i][j] = -1;
125+
} else if (i == 0 || j == 0 || j == n - 1) {
126+
f[i][j] = 0;
127+
} else {
128+
f[i][j] = Math.min(f[i - 1][j - 1], Math.min(f[i - 1][j], f[i - 1][j + 1])) + 1;
129+
ans += f[i][j];
130+
}
131+
}
132+
}
133+
return ans;
134+
}
135+
}
136+
```
137+
138+
### **C++**
139+
140+
```cpp
141+
class Solution {
142+
public:
143+
int countPyramids(vector<vector<int>>& grid) {
144+
int m = grid.size(), n = grid[0].size();
145+
int f[m][n];
146+
int ans = 0;
147+
for (int i = m - 1; ~i; --i) {
148+
for (int j = 0; j < n; ++j) {
149+
if (grid[i][j] == 0) {
150+
f[i][j] = -1;
151+
} else if (i == m - 1 || j == 0 || j == n - 1) {
152+
f[i][j] = 0;
153+
} else {
154+
f[i][j] = min({f[i + 1][j - 1], f[i + 1][j], f[i + 1][j + 1]}) + 1;
155+
ans += f[i][j];
156+
}
157+
}
158+
}
159+
for (int i = 0; i < m; ++i) {
160+
for (int j = 0; j < n; ++j) {
161+
if (grid[i][j] == 0) {
162+
f[i][j] = -1;
163+
} else if (i == 0 || j == 0 || j == n - 1) {
164+
f[i][j] = 0;
165+
} else {
166+
f[i][j] = min({f[i - 1][j - 1], f[i - 1][j], f[i - 1][j + 1]}) + 1;
167+
ans += f[i][j];
168+
}
169+
}
170+
}
171+
return ans;
172+
}
173+
};
174+
```
81175
176+
### **Go**
177+
178+
```go
179+
func countPyramids(grid [][]int) (ans int) {
180+
m, n := len(grid), len(grid[0])
181+
f := make([][]int, m)
182+
for i := range f {
183+
f[i] = make([]int, n)
184+
}
185+
for i := m - 1; i >= 0; i-- {
186+
for j := 0; j < n; j++ {
187+
if grid[i][j] == 0 {
188+
f[i][j] = -1
189+
} else if i == m-1 || j == 0 || j == n-1 {
190+
f[i][j] = 0
191+
} else {
192+
f[i][j] = min(f[i+1][j-1], min(f[i+1][j], f[i+1][j+1])) + 1
193+
ans += f[i][j]
194+
}
195+
}
196+
}
197+
for i := 0; i < m; i++ {
198+
for j := 0; j < n; j++ {
199+
if grid[i][j] == 0 {
200+
f[i][j] = -1
201+
} else if i == 0 || j == 0 || j == n-1 {
202+
f[i][j] = 0
203+
} else {
204+
f[i][j] = min(f[i-1][j-1], min(f[i-1][j], f[i-1][j+1])) + 1
205+
ans += f[i][j]
206+
}
207+
}
208+
}
209+
return
210+
}
211+
212+
func min(a, b int) int {
213+
if a < b {
214+
return a
215+
}
216+
return b
217+
}
82218
```
83219

84220
### **...**

‎solution/2000-2099/2088.Count Fertile Pyramids in a Land/Solution.cpp

Lines changed: 33 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
1+
class Solution {
2+
public:
3+
int countPyramids(vector<vector<int>>& grid) {
4+
int m = grid.size(), n = grid[0].size();
5+
int f[m][n];
6+
int ans = 0;
7+
for (int i = m - 1; ~i; --i) {
8+
for (int j = 0; j < n; ++j) {
9+
if (grid[i][j] == 0) {
10+
f[i][j] = -1;
11+
} else if (i == m - 1 || j == 0 || j == n - 1) {
12+
f[i][j] = 0;
13+
} else {
14+
f[i][j] = min({f[i + 1][j - 1], f[i + 1][j], f[i + 1][j + 1]}) + 1;
15+
ans += f[i][j];
16+
}
17+
}
18+
}
19+
for (int i = 0; i < m; ++i) {
20+
for (int j = 0; j < n; ++j) {
21+
if (grid[i][j] == 0) {
22+
f[i][j] = -1;
23+
} else if (i == 0 || j == 0 || j == n - 1) {
24+
f[i][j] = 0;
25+
} else {
26+
f[i][j] = min({f[i - 1][j - 1], f[i - 1][j], f[i - 1][j + 1]}) + 1;
27+
ans += f[i][j];
28+
}
29+
}
30+
}
31+
return ans;
32+
}
33+
};

0 commit comments

Comments
 (0)