Skip to content

Commit 19aee62

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0741.Cherry Pickup
1 parent e28925a commit 19aee62

File tree

6 files changed

+426
-3
lines changed

6 files changed

+426
-3
lines changed

‎solution/0700-0799/0741.Cherry Pickup/README.md

+147-2
Original file line numberDiff line numberDiff line change
@@ -46,27 +46,172 @@
4646
<li>可以保证起点&nbsp;<code>grid[0][0]</code>&nbsp;和终点&nbsp;<code>grid[N-1][N-1]</code>&nbsp;的值都不会是 -1。</li>
4747
</ul>
4848

49-
5049
## 解法
5150

5251
<!-- 这里可写通用的实现逻辑 -->
5352

53+
动态规划 - 数字三角形模型。
54+
55+
类似题型：方格取数、传纸条。
56+
5457
<!-- tabs:start -->
5558

5659
### **Python3**
5760

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

6063
```python
61-
64+
class Solution:
65+
def cherryPickup(self, grid: List[List[int]]) -> int:
66+
n = len(grid)
67+
dp = [[[float('-inf')] * n for _ in range(n)] for _ in range((n << 1) -1 )]
68+
dp[0][0][0] = grid[0][0]
69+
for k in range(1, (n << 1) - 1):
70+
for i1 in range(n):
71+
for i2 in range(n):
72+
j1, j2 = k - i1, k - i2
73+
if j1 >= 0 and j1 < n and j2 >= 0 and j2 < n:
74+
if grid[i1][j1] == -1 or grid[i2][j2] == -1:
75+
continue
76+
t = grid[i1][j1]
77+
if i1 != i2:
78+
t += grid[i2][j2]
79+
for p1 in range(i1 - 1, i1 + 1):
80+
for p2 in range(i2 - 1, i2 + 1):
81+
if p1 >= 0 and p2 >= 0:
82+
dp[k][i1][i2] = max(dp[k][i1][i2], dp[k - 1][p1][p2] + t)
83+
return max(dp[-1][-1][-1], 0)
6284
```
6385

6486
### **Java**
6587

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

6890
```java
91+
class Solution {
92+
public int cherryPickup(int[][] grid) {
93+
int n = grid.length;
94+
int[][][] dp = new int[2 * n][n][n];
95+
for (int[][] item : dp) {
96+
for (int[] row : item) {
97+
Arrays.fill(row, Integer.MIN_VALUE);
98+
}
99+
}
100+
dp[0][0][0] = grid[0][0];
101+
for (int k = 1; k < 2 * n - 1; ++k) {
102+
for (int i1 = 0; i1 < n; ++i1) {
103+
for (int i2 = 0; i2 < n; ++i2) {
104+
int j1 = k - i1, j2 = k - i2;
105+
if (j1 >= 0 && j1 < n && j2 >= 0 && j2 < n) {
106+
if (grid[i1][j1] == -1 || grid[i2][j2] == -1) {
107+
continue;
108+
}
109+
int t = grid[i1][j1];
110+
if (i1 != i2) {
111+
t += grid[i2][j2];
112+
}
113+
for (int p1 = i1 - 1; p1 <= i1; ++p1) {
114+
for (int p2 = i2 - 1; p2 <= i2; ++p2) {
115+
if (p1 >= 0 && p2 >= 0) {
116+
dp[k][i1][i2] = Math.max(dp[k][i1][i2], dp[k - 1][p1][p2] + t);
117+
}
118+
}
119+
}
120+
}
121+
}
122+
}
123+
}
124+
return Math.max(dp[2 * n - 2][n - 1][n - 1], 0);
125+
}
126+
}
127+
```
128+
129+
### **C++**
130+
131+
```cpp
132+
class Solution {
133+
public:
134+
int cherryPickup(vector<vector<int>>& grid) {
135+
int n = grid.size();
136+
vector<vector<vector<int>>> dp(n << 1, vector<vector<int>>(n, vector<int>(n, -1e9)));
137+
dp[0][0][0] = grid[0][0];
138+
for (int k = 1; k < 2 * n - 1; ++k)
139+
{
140+
for (int i1 = 0; i1 < n; ++i1)
141+
{
142+
for (int i2 = 0; i2 < n; ++i2)
143+
{
144+
int j1 = k - i1, j2 = k - i2;
145+
if (j1 >= 0 && j1 < n && j2 >= 0 && j2 < n)
146+
{
147+
if (grid[i1][j1] == -1 || grid[i2][j2] == -1) continue;
148+
int t = grid[i1][j1];
149+
if (i1 != i2) t += grid[i2][j2];
150+
for (int p1 = i1 - 1; p1 <= i1; ++p1)
151+
{
152+
for (int p2 = i2 - 1; p2 <= i2; ++p2)
153+
{
154+
if (p1 >= 0 && p2 >= 0) dp[k][i1][i2] = max(dp[k][i1][i2], dp[k - 1][p1][p2] + t);
155+
}
156+
}
157+
}
158+
}
159+
}
160+
}
161+
return max(dp[2 * n - 2][n - 1][n - 1], 0);
162+
}
163+
};
164+
```
69165
166+
### **Go**
167+
168+
```go
169+
func cherryPickup(grid [][]int) int {
170+
n := len(grid)
171+
dp := make([][][]int, (n << 1) - 1)
172+
for i := range dp {
173+
dp[i] = make([][]int, n)
174+
for j := range dp[i] {
175+
dp[i][j] = make([]int, n)
176+
for k := range dp[i][j] {
177+
dp[i][j][k] = int(-1e9)
178+
}
179+
}
180+
}
181+
dp[0][0][0] = grid[0][0]
182+
for k := 1; k < (n << 1) - 1; k++ {
183+
for i1 := 0; i1 < n; i1++ {
184+
for i2 := 0; i2 < n; i2++ {
185+
j1, j2 := k - i1, k - i2
186+
if j1 >= 0 && j1 < n && j2 >= 0 && j2 < n {
187+
if grid[i1][j1] == -1 || grid[i2][j2] == -1 {
188+
continue
189+
}
190+
t := grid[i1][j1]
191+
if i1 != i2 {
192+
t += grid[i2][j2]
193+
}
194+
for p1 := i1 - 1; p1 <= i1; p1++ {
195+
for p2 := i2 - 1; p2 <= i2; p2++ {
196+
if p1 >= 0 && p2 >= 0 {
197+
dp[k][i1][i2] = max(dp[k][i1][i2], dp[k - 1][p1][p2] + t)
198+
}
199+
}
200+
}
201+
}
202+
}
203+
}
204+
}
205+
206+
return max(dp[(n << 1) - 2][n - 1][n - 1], 0)
207+
}
208+
209+
func max(a, b int) int {
210+
if a > b {
211+
return a
212+
}
213+
return b
214+
}
70215
```
71216

72217
### **...**

‎solution/0700-0799/0741.Cherry Pickup/README_EN.md

+145-1
Original file line numberDiff line numberDiff line change
@@ -55,18 +55,162 @@ The total number of cherries picked up is 5, and this is the maximum possible.
5555

5656
## Solutions
5757

58+
Dynamic programming.
59+
5860
<!-- tabs:start -->
5961

6062
### **Python3**
6163

6264
```python
63-
65+
class Solution:
66+
def cherryPickup(self, grid: List[List[int]]) -> int:
67+
n = len(grid)
68+
dp = [[[float('-inf')] * n for _ in range(n)] for _ in range((n << 1) -1 )]
69+
dp[0][0][0] = grid[0][0]
70+
for k in range(1, (n << 1) - 1):
71+
for i1 in range(n):
72+
for i2 in range(n):
73+
j1, j2 = k - i1, k - i2
74+
if j1 >= 0 and j1 < n and j2 >= 0 and j2 < n:
75+
if grid[i1][j1] == -1 or grid[i2][j2] == -1:
76+
continue
77+
t = grid[i1][j1]
78+
if i1 != i2:
79+
t += grid[i2][j2]
80+
for p1 in range(i1 - 1, i1 + 1):
81+
for p2 in range(i2 - 1, i2 + 1):
82+
if p1 >= 0 and p2 >= 0:
83+
dp[k][i1][i2] = max(dp[k][i1][i2], dp[k - 1][p1][p2] + t)
84+
return max(dp[-1][-1][-1], 0)
6485
```
6586

6687
### **Java**
6788

6889
```java
90+
class Solution {
91+
public int cherryPickup(int[][] grid) {
92+
int n = grid.length;
93+
int[][][] dp = new int[2 * n][n][n];
94+
for (int[][] item : dp) {
95+
for (int[] row : item) {
96+
Arrays.fill(row, Integer.MIN_VALUE);
97+
}
98+
}
99+
dp[0][0][0] = grid[0][0];
100+
for (int k = 1; k < 2 * n - 1; ++k) {
101+
for (int i1 = 0; i1 < n; ++i1) {
102+
for (int i2 = 0; i2 < n; ++i2) {
103+
int j1 = k - i1, j2 = k - i2;
104+
if (j1 >= 0 && j1 < n && j2 >= 0 && j2 < n) {
105+
if (grid[i1][j1] == -1 || grid[i2][j2] == -1) {
106+
continue;
107+
}
108+
int t = grid[i1][j1];
109+
if (i1 != i2) {
110+
t += grid[i2][j2];
111+
}
112+
for (int p1 = i1 - 1; p1 <= i1; ++p1) {
113+
for (int p2 = i2 - 1; p2 <= i2; ++p2) {
114+
if (p1 >= 0 && p2 >= 0) {
115+
dp[k][i1][i2] = Math.max(dp[k][i1][i2], dp[k - 1][p1][p2] + t);
116+
}
117+
}
118+
}
119+
}
120+
}
121+
}
122+
}
123+
return Math.max(dp[2 * n - 2][n - 1][n - 1], 0);
124+
}
125+
}
126+
```
127+
128+
### **C++**
129+
130+
```cpp
131+
class Solution {
132+
public:
133+
int cherryPickup(vector<vector<int>>& grid) {
134+
int n = grid.size();
135+
vector<vector<vector<int>>> dp(n << 1, vector<vector<int>>(n, vector<int>(n, -1e9)));
136+
dp[0][0][0] = grid[0][0];
137+
for (int k = 1; k < 2 * n - 1; ++k)
138+
{
139+
for (int i1 = 0; i1 < n; ++i1)
140+
{
141+
for (int i2 = 0; i2 < n; ++i2)
142+
{
143+
int j1 = k - i1, j2 = k - i2;
144+
if (j1 >= 0 && j1 < n && j2 >= 0 && j2 < n)
145+
{
146+
if (grid[i1][j1] == -1 || grid[i2][j2] == -1) continue;
147+
int t = grid[i1][j1];
148+
if (i1 != i2) t += grid[i2][j2];
149+
for (int p1 = i1 - 1; p1 <= i1; ++p1)
150+
{
151+
for (int p2 = i2 - 1; p2 <= i2; ++p2)
152+
{
153+
if (p1 >= 0 && p2 >= 0) dp[k][i1][i2] = max(dp[k][i1][i2], dp[k - 1][p1][p2] + t);
154+
}
155+
}
156+
}
157+
}
158+
}
159+
}
160+
return max(dp[2 * n - 2][n - 1][n - 1], 0);
161+
}
162+
};
163+
```
69164
165+
### **Go**
166+
167+
```go
168+
func cherryPickup(grid [][]int) int {
169+
n := len(grid)
170+
dp := make([][][]int, (n << 1) - 1)
171+
for i := range dp {
172+
dp[i] = make([][]int, n)
173+
for j := range dp[i] {
174+
dp[i][j] = make([]int, n)
175+
for k := range dp[i][j] {
176+
dp[i][j][k] = int(-1e9)
177+
}
178+
}
179+
}
180+
dp[0][0][0] = grid[0][0]
181+
for k := 1; k < (n << 1) - 1; k++ {
182+
for i1 := 0; i1 < n; i1++ {
183+
for i2 := 0; i2 < n; i2++ {
184+
j1, j2 := k - i1, k - i2
185+
if j1 >= 0 && j1 < n && j2 >= 0 && j2 < n {
186+
if grid[i1][j1] == -1 || grid[i2][j2] == -1 {
187+
continue
188+
}
189+
t := grid[i1][j1]
190+
if i1 != i2 {
191+
t += grid[i2][j2]
192+
}
193+
for p1 := i1 - 1; p1 <= i1; p1++ {
194+
for p2 := i2 - 1; p2 <= i2; p2++ {
195+
if p1 >= 0 && p2 >= 0 {
196+
dp[k][i1][i2] = max(dp[k][i1][i2], dp[k - 1][p1][p2] + t)
197+
}
198+
}
199+
}
200+
}
201+
}
202+
}
203+
}
204+
205+
return max(dp[(n << 1) - 2][n - 1][n - 1], 0)
206+
}
207+
208+
func max(a, b int) int {
209+
if a > b {
210+
return a
211+
}
212+
return b
213+
}
70214
```
71215

72216
### **...**

‎solution/0700-0799/0741.Cherry Pickup/Solution.cpp

+32
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
class Solution {
2+
public:
3+
int cherryPickup(vector<vector<int>>& grid) {
4+
int n = grid.size();
5+
vector<vector<vector<int>>> dp(n << 1, vector<vector<int>>(n, vector<int>(n, -1e9)));
6+
dp[0][0][0] = grid[0][0];
7+
for (int k = 1; k < 2 * n - 1; ++k)
8+
{
9+
for (int i1 = 0; i1 < n; ++i1)
10+
{
11+
for (int i2 = 0; i2 < n; ++i2)
12+
{
13+
int j1 = k - i1, j2 = k - i2;
14+
if (j1 >= 0 && j1 < n && j2 >= 0 && j2 < n)
15+
{
16+
if (grid[i1][j1] == -1 || grid[i2][j2] == -1) continue;
17+
int t = grid[i1][j1];
18+
if (i1 != i2) t += grid[i2][j2];
19+
for (int p1 = i1 - 1; p1 <= i1; ++p1)
20+
{
21+
for (int p2 = i2 - 1; p2 <= i2; ++p2)
22+
{
23+
if (p1 >= 0 && p2 >= 0) dp[k][i1][i2] = max(dp[k][i1][i2], dp[k - 1][p1][p2] + t);
24+
}
25+
}
26+
}
27+
}
28+
}
29+
}
30+
return max(dp[2 * n - 2][n - 1][n - 1], 0);
31+
}
32+
};

0 commit comments

Comments
 (0)