Skip to content

Commit 6fe2fcf

Browse files
yanglbmeyanglbme
authoredMay 6, 2024··
feat: add solutions to lc problem: No.0741 (#2723)
No.0741.Cherry Pickup
·
v0.3.0v0.2.0
1 parent 739df2d commit 6fe2fcf

File tree

8 files changed

+257
-139
lines changed

8 files changed

+257
-139
lines changed
 

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

+89-48
Original file line numberDiff line numberDiff line change
@@ -62,20 +62,28 @@
6262

6363
### 方法一：动态规划
6464

65-
线性 DP。题目中，玩家从 `(0, 0)` 到 `(N-1, N-1)` 后又重新返回到起始点 `(0, 0)`，我们可以视为玩家两次从 `(0, 0)` 出发到 `(N-1, N-1)`。
65+
根据题目描述，玩家从 $(0, 0)$ 出发，到达 $(n-1, n-1)$ 后，又重新返回到起始点 $(0, 0)$，我们可以视为玩家两次从 $(0, 0)$ 出发，到达 $(n-1, n-1)$。
6666

67-
定义 `dp[k][i1][i2]` 表示两次路径同时走了 k 步，并且第一次走到 `(i1, k-i1)`，第二次走到 `(i2, k-i2)` 的所有路径中，可获得的樱桃数量的最大值。
67+
因此，我们定义 $f[k][i_1][i_2]$ 表示两次都走了 $k$ 步，分别到达 $(i_1, k-i_1)$ 和 $(i_2, k-i_2)$ 时，能够摘到的最多樱桃数。初始时 $f[0][0][0] = grid[0][0]$。其余 $f[k][i_1][i_2]$ 的初始值为负无穷。答案为 $\max(0, f[2n-2][n-1][n-1])$。
6868

69-
类似题型：方格取数、传纸条。
69+
我们可以根据题目描述，得到状态转移方程：
70+
71+
$$
72+
f[k][i_1][i_2] = \max(f[k-1][x_1][x_2] + t, f[k][i_1][i_2])
73+
$$
74+
75+
其中 $t$ 表示 $(i_1, k-i_1)$ 和 $(i_2, k-i_2)$ 位置上的樱桃数，而 $x_1, x_2$ 分别表示 $(i_1, k-i_1)$ 和 $(i_2, k-i_2)$ 的前一步位置。
76+
77+
时间复杂度 $O(n^3)$，空间复杂度 $O(n^3)$。其中 $n$ 表示网格的边长。
7078

7179
<!-- tabs:start -->
7280

7381
```python
7482
class Solution:
7583
def cherryPickup(self, grid: List[List[int]]) -> int:
7684
n = len(grid)
77-
dp = [[[-inf] * n for _ in range(n)] for _ in range((n << 1) - 1)]
78-
dp[0][0][0] = grid[0][0]
85+
f = [[[-inf] * n for _ in range(n)] for _ in range((n << 1) - 1)]
86+
f[0][0][0] = grid[0][0]
7987
for k in range(1, (n << 1) - 1):
8088
for i1 in range(n):
8189
for i2 in range(n):
@@ -93,23 +101,21 @@ class Solution:
93101
for x1 in range(i1 - 1, i1 + 1):
94102
for x2 in range(i2 - 1, i2 + 1):
95103
if x1 >= 0 and x2 >= 0:
96-
dp[k][i1][i2] = max(
97-
dp[k][i1][i2], dp[k - 1][x1][x2] + t
98-
)
99-
return max(0, dp[-1][-1][-1])
104+
f[k][i1][i2] = max(f[k][i1][i2], f[k - 1][x1][x2] + t)
105+
return max(0, f[-1][-1][-1])
100106
```
101107

102108
```java
103109
class Solution {
104110
public int cherryPickup(int[][] grid) {
105111
int n = grid.length;
106-
int[][][] dp = new int[n * 2][n][n];
107-
dp[0][0][0] = grid[0][0];
112+
int[][][] f = new int[n * 2][n][n];
113+
f[0][0][0] = grid[0][0];
108114
for (int k = 1; k < n * 2 - 1; ++k) {
109115
for (int i1 = 0; i1 < n; ++i1) {
110116
for (int i2 = 0; i2 < n; ++i2) {
111117
int j1 = k - i1, j2 = k - i2;
112-
dp[k][i1][i2] = Integer.MIN_VALUE;
118+
f[k][i1][i2] = Integer.MIN_VALUE;
113119
if (j1 < 0 || j1 >= n || j2 < 0 || j2 >= n || grid[i1][j1] == -1
114120
|| grid[i2][j2] == -1) {
115121
continue;
@@ -121,14 +127,14 @@ class Solution {
121127
for (int x1 = i1 - 1; x1 <= i1; ++x1) {
122128
for (int x2 = i2 - 1; x2 <= i2; ++x2) {
123129
if (x1 >= 0 && x2 >= 0) {
124-
dp[k][i1][i2] = Math.max(dp[k][i1][i2], dp[k - 1][x1][x2] + t);
130+
f[k][i1][i2] = Math.max(f[k][i1][i2], f[k - 1][x1][x2] + t);
125131
}
126132
}
127133
}
128134
}
129135
}
130136
}
131-
return Math.max(0, dp[n * 2 - 2][n - 1][n - 1]);
137+
return Math.max(0, f[n * 2 - 2][n - 1][n - 1]);
132138
}
133139
}
134140
```
@@ -138,42 +144,49 @@ class Solution {
138144
public:
139145
int cherryPickup(vector<vector<int>>& grid) {
140146
int n = grid.size();
141-
vector<vector<vector<int>>> dp(n << 1, vector<vector<int>>(n, vector<int>(n, -1e9)));
142-
dp[0][0][0] = grid[0][0];
147+
vector<vector<vector<int>>> f(n << 1, vector<vector<int>>(n, vector<int>(n, -1e9)));
148+
f[0][0][0] = grid[0][0];
143149
for (int k = 1; k < n * 2 - 1; ++k) {
144150
for (int i1 = 0; i1 < n; ++i1) {
145151
for (int i2 = 0; i2 < n; ++i2) {
146152
int j1 = k - i1, j2 = k - i2;
147-
if (j1 < 0 || j1 >= n || j2 < 0 || j2 >= n || grid[i1][j1] == -1 || grid[i2][j2] == -1) continue;
153+
if (j1 < 0 || j1 >= n || j2 < 0 || j2 >= n || grid[i1][j1] == -1 || grid[i2][j2] == -1) {
154+
continue;
155+
}
148156
int t = grid[i1][j1];
149-
if (i1 != i2) t += grid[i2][j2];
150-
for (int x1 = i1 - 1; x1 <= i1; ++x1)
151-
for (int x2 = i2 - 1; x2 <= i2; ++x2)
152-
if (x1 >= 0 && x2 >= 0)
153-
dp[k][i1][i2] = max(dp[k][i1][i2], dp[k - 1][x1][x2] + t);
157+
if (i1 != i2) {
158+
t += grid[i2][j2];
159+
}
160+
for (int x1 = i1 - 1; x1 <= i1; ++x1) {
161+
for (int x2 = i2 - 1; x2 <= i2; ++x2) {
162+
if (x1 >= 0 && x2 >= 0) {
163+
f[k][i1][i2] = max(f[k][i1][i2], f[k - 1][x1][x2] + t);
164+
}
165+
}
166+
}
154167
}
155168
}
156169
}
157-
return max(0, dp[n * 2 - 2][n - 1][n - 1]);
170+
return max(0, f[n * 2 - 2][n - 1][n - 1]);
158171
}
159172
};
160173
```
161174
162175
```go
163176
func cherryPickup(grid [][]int) int {
164177
n := len(grid)
165-
dp := make([][][]int, (n<<1)-1)
166-
for i := range dp {
167-
dp[i] = make([][]int, n)
168-
for j := range dp[i] {
169-
dp[i][j] = make([]int, n)
178+
f := make([][][]int, (n<<1)-1)
179+
for i := range f {
180+
f[i] = make([][]int, n)
181+
for j := range f[i] {
182+
f[i][j] = make([]int, n)
170183
}
171184
}
172-
dp[0][0][0] = grid[0][0]
185+
f[0][0][0] = grid[0][0]
173186
for k := 1; k < (n<<1)-1; k++ {
174187
for i1 := 0; i1 < n; i1++ {
175188
for i2 := 0; i2 < n; i2++ {
176-
dp[k][i1][i2] = int(-1e9)
189+
f[k][i1][i2] = int(-1e9)
177190
j1, j2 := k-i1, k-i2
178191
if j1 < 0 || j1 >= n || j2 < 0 || j2 >= n || grid[i1][j1] == -1 || grid[i2][j2] == -1 {
179192
continue
@@ -185,14 +198,50 @@ func cherryPickup(grid [][]int) int {
185198
for x1 := i1 - 1; x1 <= i1; x1++ {
186199
for x2 := i2 - 1; x2 <= i2; x2++ {
187200
if x1 >= 0 && x2 >= 0 {
188-
dp[k][i1][i2] = max(dp[k][i1][i2], dp[k-1][x1][x2]+t)
201+
f[k][i1][i2] = max(f[k][i1][i2], f[k-1][x1][x2]+t)
189202
}
190203
}
191204
}
192205
}
193206
}
194207
}
195-
return max(0, dp[n*2-2][n-1][n-1])
208+
return max(0, f[n*2-2][n-1][n-1])
209+
}
210+
```
211+
212+
```ts
213+
function cherryPickup(grid: number[][]): number {
214+
const n: number = grid.length;
215+
const f: number[][][] = Array.from({ length: n * 2 - 1 }, () =>
216+
Array.from({ length: n }, () => Array.from({ length: n }, () => -Infinity)),
217+
);
218+
f[0][0][0] = grid[0][0];
219+
for (let k = 1; k < n * 2 - 1; ++k) {
220+
for (let i1 = 0; i1 < n; ++i1) {
221+
for (let i2 = 0; i2 < n; ++i2) {
222+
const [j1, j2]: [number, number] = [k - i1, k - i2];
223+
if (
224+
j1 < 0 ||
225+
j1 >= n ||
226+
j2 < 0 ||
227+
j2 >= n ||
228+
grid[i1][j1] == -1 ||
229+
grid[i2][j2] == -1
230+
) {
231+
continue;
232+
}
233+
const t: number = grid[i1][j1] + (i1 != i2 ? grid[i2][j2] : 0);
234+
for (let x1 = i1 - 1; x1 <= i1; ++x1) {
235+
for (let x2 = i2 - 1; x2 <= i2; ++x2) {
236+
if (x1 >= 0 && x2 >= 0) {
237+
f[k][i1][i2] = Math.max(f[k][i1][i2], f[k - 1][x1][x2] + t);
238+
}
239+
}
240+
}
241+
}
242+
}
243+
}
244+
return Math.max(0, f[n * 2 - 2][n - 1][n - 1]);
196245
}
197246
```
198247

@@ -203,19 +252,14 @@ func cherryPickup(grid [][]int) int {
203252
*/
204253
var cherryPickup = function (grid) {
205254
const n = grid.length;
206-
let dp = new Array(n * 2 - 1);
207-
for (let k = 0; k < dp.length; ++k) {
208-
dp[k] = new Array(n);
209-
for (let i = 0; i < n; ++i) {
210-
dp[k][i] = new Array(n).fill(-1e9);
211-
}
212-
}
213-
dp[0][0][0] = grid[0][0];
255+
const f = Array.from({ length: n * 2 - 1 }, () =>
256+
Array.from({ length: n }, () => Array.from({ length: n }, () => -Infinity)),
257+
);
258+
f[0][0][0] = grid[0][0];
214259
for (let k = 1; k < n * 2 - 1; ++k) {
215260
for (let i1 = 0; i1 < n; ++i1) {
216261
for (let i2 = 0; i2 < n; ++i2) {
217-
const j1 = k - i1,
218-
j2 = k - i2;
262+
const [j1, j2] = [k - i1, k - i2];
219263
if (
220264
j1 < 0 ||
221265
j1 >= n ||
@@ -226,21 +270,18 @@ var cherryPickup = function (grid) {
226270
) {
227271
continue;
228272
}
229-
let t = grid[i1][j1];
230-
if (i1 != i2) {
231-
t += grid[i2][j2];
232-
}
273+
const t = grid[i1][j1] + (i1 != i2 ? grid[i2][j2] : 0);
233274
for (let x1 = i1 - 1; x1 <= i1; ++x1) {
234275
for (let x2 = i2 - 1; x2 <= i2; ++x2) {
235276
if (x1 >= 0 && x2 >= 0) {
236-
dp[k][i1][i2] = Math.max(dp[k][i1][i2], dp[k - 1][x1][x2] + t);
277+
f[k][i1][i2] = Math.max(f[k][i1][i2], f[k - 1][x1][x2] + t);
237278
}
238279
}
239280
}
240281
}
241282
}
242283
}
243-
return Math.max(0, dp[n * 2 - 2][n - 1][n - 1]);
284+
return Math.max(0, f[n * 2 - 2][n - 1][n - 1]);
244285
};
245286
```
246287

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

+93-46
Original file line numberDiff line numberDiff line change
@@ -56,16 +56,30 @@ The total number of cherries picked up is 5, and this is the maximum possible.
5656

5757
## Solutions
5858

59-
### Solution 1
59+
### Solution 1: Dynamic Programming
60+
61+
According to the problem description, the player starts from $(0, 0)$, reaches $(n-1, n-1)$, and then returns to the starting point $(0, 0)$. We can consider the player as starting from $(0, 0)$ to $(n-1, n-1)$ twice.
62+
63+
Therefore, we define $f[k][i_1][i_2]$ as the maximum number of cherries that can be picked when both have walked $k$ steps and reached $(i_1, k-i_1)$ and $(i_2, k-i_2)$ respectively. Initially, $f[0][0][0] = grid[0][0]$. The initial values of other $f[k][i_1][i_2]$ are negative infinity. The answer is $\max(0, f[2n-2][n-1][n-1])$.
64+
65+
According to the problem description, we can get the state transition equation:
66+
67+
$$
68+
f[k][i_1][i_2] = \max(f[k-1][x_1][x_2] + t, f[k][i_1][i_2])
69+
$$
70+
71+
Where $t$ represents the number of cherries at positions $(i_1, k-i_1)$ and $(i_2, k-i_2)$, and $x_1, x_2$ represent the previous step positions of $(i_1, k-i_1)$ and $(i_2, k-i_2)$ respectively.
72+
73+
The time complexity is $O(n^3)$, and the space complexity is $O(n^3)$. Where $n$ is the side length of the grid.
6074

6175
<!-- tabs:start -->
6276

6377
```python
6478
class Solution:
6579
def cherryPickup(self, grid: List[List[int]]) -> int:
6680
n = len(grid)
67-
dp = [[[-inf] * n for _ in range(n)] for _ in range((n << 1) - 1)]
68-
dp[0][0][0] = grid[0][0]
81+
f = [[[-inf] * n for _ in range(n)] for _ in range((n << 1) - 1)]
82+
f[0][0][0] = grid[0][0]
6983
for k in range(1, (n << 1) - 1):
7084
for i1 in range(n):
7185
for i2 in range(n):
@@ -83,23 +97,21 @@ class Solution:
8397
for x1 in range(i1 - 1, i1 + 1):
8498
for x2 in range(i2 - 1, i2 + 1):
8599
if x1 >= 0 and x2 >= 0:
86-
dp[k][i1][i2] = max(
87-
dp[k][i1][i2], dp[k - 1][x1][x2] + t
88-
)
89-
return max(0, dp[-1][-1][-1])
100+
f[k][i1][i2] = max(f[k][i1][i2], f[k - 1][x1][x2] + t)
101+
return max(0, f[-1][-1][-1])
90102
```
91103

92104
```java
93105
class Solution {
94106
public int cherryPickup(int[][] grid) {
95107
int n = grid.length;
96-
int[][][] dp = new int[n * 2][n][n];
97-
dp[0][0][0] = grid[0][0];
108+
int[][][] f = new int[n * 2][n][n];
109+
f[0][0][0] = grid[0][0];
98110
for (int k = 1; k < n * 2 - 1; ++k) {
99111
for (int i1 = 0; i1 < n; ++i1) {
100112
for (int i2 = 0; i2 < n; ++i2) {
101113
int j1 = k - i1, j2 = k - i2;
102-
dp[k][i1][i2] = Integer.MIN_VALUE;
114+
f[k][i1][i2] = Integer.MIN_VALUE;
103115
if (j1 < 0 || j1 >= n || j2 < 0 || j2 >= n || grid[i1][j1] == -1
104116
|| grid[i2][j2] == -1) {
105117
continue;
@@ -111,14 +123,14 @@ class Solution {
111123
for (int x1 = i1 - 1; x1 <= i1; ++x1) {
112124
for (int x2 = i2 - 1; x2 <= i2; ++x2) {
113125
if (x1 >= 0 && x2 >= 0) {
114-
dp[k][i1][i2] = Math.max(dp[k][i1][i2], dp[k - 1][x1][x2] + t);
126+
f[k][i1][i2] = Math.max(f[k][i1][i2], f[k - 1][x1][x2] + t);
115127
}
116128
}
117129
}
118130
}
119131
}
120132
}
121-
return Math.max(0, dp[n * 2 - 2][n - 1][n - 1]);
133+
return Math.max(0, f[n * 2 - 2][n - 1][n - 1]);
122134
}
123135
}
124136
```
@@ -128,42 +140,49 @@ class Solution {
128140
public:
129141
int cherryPickup(vector<vector<int>>& grid) {
130142
int n = grid.size();
131-
vector<vector<vector<int>>> dp(n << 1, vector<vector<int>>(n, vector<int>(n, -1e9)));
132-
dp[0][0][0] = grid[0][0];
143+
vector<vector<vector<int>>> f(n << 1, vector<vector<int>>(n, vector<int>(n, -1e9)));
144+
f[0][0][0] = grid[0][0];
133145
for (int k = 1; k < n * 2 - 1; ++k) {
134146
for (int i1 = 0; i1 < n; ++i1) {
135147
for (int i2 = 0; i2 < n; ++i2) {
136148
int j1 = k - i1, j2 = k - i2;
137-
if (j1 < 0 || j1 >= n || j2 < 0 || j2 >= n || grid[i1][j1] == -1 || grid[i2][j2] == -1) continue;
149+
if (j1 < 0 || j1 >= n || j2 < 0 || j2 >= n || grid[i1][j1] == -1 || grid[i2][j2] == -1) {
150+
continue;
151+
}
138152
int t = grid[i1][j1];
139-
if (i1 != i2) t += grid[i2][j2];
140-
for (int x1 = i1 - 1; x1 <= i1; ++x1)
141-
for (int x2 = i2 - 1; x2 <= i2; ++x2)
142-
if (x1 >= 0 && x2 >= 0)
143-
dp[k][i1][i2] = max(dp[k][i1][i2], dp[k - 1][x1][x2] + t);
153+
if (i1 != i2) {
154+
t += grid[i2][j2];
155+
}
156+
for (int x1 = i1 - 1; x1 <= i1; ++x1) {
157+
for (int x2 = i2 - 1; x2 <= i2; ++x2) {
158+
if (x1 >= 0 && x2 >= 0) {
159+
f[k][i1][i2] = max(f[k][i1][i2], f[k - 1][x1][x2] + t);
160+
}
161+
}
162+
}
144163
}
145164
}
146165
}
147-
return max(0, dp[n * 2 - 2][n - 1][n - 1]);
166+
return max(0, f[n * 2 - 2][n - 1][n - 1]);
148167
}
149168
};
150169
```
151170
152171
```go
153172
func cherryPickup(grid [][]int) int {
154173
n := len(grid)
155-
dp := make([][][]int, (n<<1)-1)
156-
for i := range dp {
157-
dp[i] = make([][]int, n)
158-
for j := range dp[i] {
159-
dp[i][j] = make([]int, n)
174+
f := make([][][]int, (n<<1)-1)
175+
for i := range f {
176+
f[i] = make([][]int, n)
177+
for j := range f[i] {
178+
f[i][j] = make([]int, n)
160179
}
161180
}
162-
dp[0][0][0] = grid[0][0]
181+
f[0][0][0] = grid[0][0]
163182
for k := 1; k < (n<<1)-1; k++ {
164183
for i1 := 0; i1 < n; i1++ {
165184
for i2 := 0; i2 < n; i2++ {
166-
dp[k][i1][i2] = int(-1e9)
185+
f[k][i1][i2] = int(-1e9)
167186
j1, j2 := k-i1, k-i2
168187
if j1 < 0 || j1 >= n || j2 < 0 || j2 >= n || grid[i1][j1] == -1 || grid[i2][j2] == -1 {
169188
continue
@@ -175,14 +194,50 @@ func cherryPickup(grid [][]int) int {
175194
for x1 := i1 - 1; x1 <= i1; x1++ {
176195
for x2 := i2 - 1; x2 <= i2; x2++ {
177196
if x1 >= 0 && x2 >= 0 {
178-
dp[k][i1][i2] = max(dp[k][i1][i2], dp[k-1][x1][x2]+t)
197+
f[k][i1][i2] = max(f[k][i1][i2], f[k-1][x1][x2]+t)
179198
}
180199
}
181200
}
182201
}
183202
}
184203
}
185-
return max(0, dp[n*2-2][n-1][n-1])
204+
return max(0, f[n*2-2][n-1][n-1])
205+
}
206+
```
207+
208+
```ts
209+
function cherryPickup(grid: number[][]): number {
210+
const n: number = grid.length;
211+
const f: number[][][] = Array.from({ length: n * 2 - 1 }, () =>
212+
Array.from({ length: n }, () => Array.from({ length: n }, () => -Infinity)),
213+
);
214+
f[0][0][0] = grid[0][0];
215+
for (let k = 1; k < n * 2 - 1; ++k) {
216+
for (let i1 = 0; i1 < n; ++i1) {
217+
for (let i2 = 0; i2 < n; ++i2) {
218+
const [j1, j2]: [number, number] = [k - i1, k - i2];
219+
if (
220+
j1 < 0 ||
221+
j1 >= n ||
222+
j2 < 0 ||
223+
j2 >= n ||
224+
grid[i1][j1] == -1 ||
225+
grid[i2][j2] == -1
226+
) {
227+
continue;
228+
}
229+
const t: number = grid[i1][j1] + (i1 != i2 ? grid[i2][j2] : 0);
230+
for (let x1 = i1 - 1; x1 <= i1; ++x1) {
231+
for (let x2 = i2 - 1; x2 <= i2; ++x2) {
232+
if (x1 >= 0 && x2 >= 0) {
233+
f[k][i1][i2] = Math.max(f[k][i1][i2], f[k - 1][x1][x2] + t);
234+
}
235+
}
236+
}
237+
}
238+
}
239+
}
240+
return Math.max(0, f[n * 2 - 2][n - 1][n - 1]);
186241
}
187242
```
188243

@@ -193,19 +248,14 @@ func cherryPickup(grid [][]int) int {
193248
*/
194249
var cherryPickup = function (grid) {
195250
const n = grid.length;
196-
let dp = new Array(n * 2 - 1);
197-
for (let k = 0; k < dp.length; ++k) {
198-
dp[k] = new Array(n);
199-
for (let i = 0; i < n; ++i) {
200-
dp[k][i] = new Array(n).fill(-1e9);
201-
}
202-
}
203-
dp[0][0][0] = grid[0][0];
251+
const f = Array.from({ length: n * 2 - 1 }, () =>
252+
Array.from({ length: n }, () => Array.from({ length: n }, () => -Infinity)),
253+
);
254+
f[0][0][0] = grid[0][0];
204255
for (let k = 1; k < n * 2 - 1; ++k) {
205256
for (let i1 = 0; i1 < n; ++i1) {
206257
for (let i2 = 0; i2 < n; ++i2) {
207-
const j1 = k - i1,
208-
j2 = k - i2;
258+
const [j1, j2] = [k - i1, k - i2];
209259
if (
210260
j1 < 0 ||
211261
j1 >= n ||
@@ -216,21 +266,18 @@ var cherryPickup = function (grid) {
216266
) {
217267
continue;
218268
}
219-
let t = grid[i1][j1];
220-
if (i1 != i2) {
221-
t += grid[i2][j2];
222-
}
269+
const t = grid[i1][j1] + (i1 != i2 ? grid[i2][j2] : 0);
223270
for (let x1 = i1 - 1; x1 <= i1; ++x1) {
224271
for (let x2 = i2 - 1; x2 <= i2; ++x2) {
225272
if (x1 >= 0 && x2 >= 0) {
226-
dp[k][i1][i2] = Math.max(dp[k][i1][i2], dp[k - 1][x1][x2] + t);
273+
f[k][i1][i2] = Math.max(f[k][i1][i2], f[k - 1][x1][x2] + t);
227274
}
228275
}
229276
}
230277
}
231278
}
232279
}
233-
return Math.max(0, dp[n * 2 - 2][n - 1][n - 1]);
280+
return Math.max(0, f[n * 2 - 2][n - 1][n - 1]);
234281
};
235282
```
236283

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

+16-9
Original file line numberDiff line numberDiff line change
@@ -2,22 +2,29 @@ class Solution {
22
public:
33
int cherryPickup(vector<vector<int>>& grid) {
44
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];
5+
vector<vector<vector<int>>> f(n << 1, vector<vector<int>>(n, vector<int>(n, -1e9)));
6+
f[0][0][0] = grid[0][0];
77
for (int k = 1; k < n * 2 - 1; ++k) {
88
for (int i1 = 0; i1 < n; ++i1) {
99
for (int i2 = 0; i2 < n; ++i2) {
1010
int j1 = k - i1, j2 = k - i2;
11-
if (j1 < 0 || j1 >= n || j2 < 0 || j2 >= n || grid[i1][j1] == -1 || grid[i2][j2] == -1) continue;
11+
if (j1 < 0 || j1 >= n || j2 < 0 || j2 >= n || grid[i1][j1] == -1 || grid[i2][j2] == -1) {
12+
continue;
13+
}
1214
int t = grid[i1][j1];
13-
if (i1 != i2) t += grid[i2][j2];
14-
for (int x1 = i1 - 1; x1 <= i1; ++x1)
15-
for (int x2 = i2 - 1; x2 <= i2; ++x2)
16-
if (x1 >= 0 && x2 >= 0)
17-
dp[k][i1][i2] = max(dp[k][i1][i2], dp[k - 1][x1][x2] + t);
15+
if (i1 != i2) {
16+
t += grid[i2][j2];
17+
}
18+
for (int x1 = i1 - 1; x1 <= i1; ++x1) {
19+
for (int x2 = i2 - 1; x2 <= i2; ++x2) {
20+
if (x1 >= 0 && x2 >= 0) {
21+
f[k][i1][i2] = max(f[k][i1][i2], f[k - 1][x1][x2] + t);
22+
}
23+
}
24+
}
1825
}
1926
}
2027
}
21-
return max(0, dp[n * 2 - 2][n - 1][n - 1]);
28+
return max(0, f[n * 2 - 2][n - 1][n - 1]);
2229
}
2330
};

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

+9-9
Original file line numberDiff line numberDiff line change
@@ -1,17 +1,17 @@
11
func cherryPickup(grid [][]int) int {
22
n := len(grid)
3-
dp := make([][][]int, (n<<1)-1)
4-
for i := range dp {
5-
dp[i] = make([][]int, n)
6-
for j := range dp[i] {
7-
dp[i][j] = make([]int, n)
3+
f := make([][][]int, (n<<1)-1)
4+
for i := range f {
5+
f[i] = make([][]int, n)
6+
for j := range f[i] {
7+
f[i][j] = make([]int, n)
88
}
99
}
10-
dp[0][0][0] = grid[0][0]
10+
f[0][0][0] = grid[0][0]
1111
for k := 1; k < (n<<1)-1; k++ {
1212
for i1 := 0; i1 < n; i1++ {
1313
for i2 := 0; i2 < n; i2++ {
14-
dp[k][i1][i2] = int(-1e9)
14+
f[k][i1][i2] = int(-1e9)
1515
j1, j2 := k-i1, k-i2
1616
if j1 < 0 || j1 >= n || j2 < 0 || j2 >= n || grid[i1][j1] == -1 || grid[i2][j2] == -1 {
1717
continue
@@ -23,12 +23,12 @@ func cherryPickup(grid [][]int) int {
2323
for x1 := i1 - 1; x1 <= i1; x1++ {
2424
for x2 := i2 - 1; x2 <= i2; x2++ {
2525
if x1 >= 0 && x2 >= 0 {
26-
dp[k][i1][i2] = max(dp[k][i1][i2], dp[k-1][x1][x2]+t)
26+
f[k][i1][i2] = max(f[k][i1][i2], f[k-1][x1][x2]+t)
2727
}
2828
}
2929
}
3030
}
3131
}
3232
}
33-
return max(0, dp[n*2-2][n-1][n-1])
33+
return max(0, f[n*2-2][n-1][n-1])
3434
}

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

+5-5
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,13 @@
11
class Solution {
22
public int cherryPickup(int[][] grid) {
33
int n = grid.length;
4-
int[][][] dp = new int[n * 2][n][n];
5-
dp[0][0][0] = grid[0][0];
4+
int[][][] f = new int[n * 2][n][n];
5+
f[0][0][0] = grid[0][0];
66
for (int k = 1; k < n * 2 - 1; ++k) {
77
for (int i1 = 0; i1 < n; ++i1) {
88
for (int i2 = 0; i2 < n; ++i2) {
99
int j1 = k - i1, j2 = k - i2;
10-
dp[k][i1][i2] = Integer.MIN_VALUE;
10+
f[k][i1][i2] = Integer.MIN_VALUE;
1111
if (j1 < 0 || j1 >= n || j2 < 0 || j2 >= n || grid[i1][j1] == -1
1212
|| grid[i2][j2] == -1) {
1313
continue;
@@ -19,13 +19,13 @@ public int cherryPickup(int[][] grid) {
1919
for (int x1 = i1 - 1; x1 <= i1; ++x1) {
2020
for (int x2 = i2 - 1; x2 <= i2; ++x2) {
2121
if (x1 >= 0 && x2 >= 0) {
22-
dp[k][i1][i2] = Math.max(dp[k][i1][i2], dp[k - 1][x1][x2] + t);
22+
f[k][i1][i2] = Math.max(f[k][i1][i2], f[k - 1][x1][x2] + t);
2323
}
2424
}
2525
}
2626
}
2727
}
2828
}
29-
return Math.max(0, dp[n * 2 - 2][n - 1][n - 1]);
29+
return Math.max(0, f[n * 2 - 2][n - 1][n - 1]);
3030
}
3131
}

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

+8-16
Original file line numberDiff line numberDiff line change
@@ -4,19 +4,14 @@
44
*/
55
var cherryPickup = function (grid) {
66
const n = grid.length;
7-
let dp = new Array(n * 2 - 1);
8-
for (let k = 0; k < dp.length; ++k) {
9-
dp[k] = new Array(n);
10-
for (let i = 0; i < n; ++i) {
11-
dp[k][i] = new Array(n).fill(-1e9);
12-
}
13-
}
14-
dp[0][0][0] = grid[0][0];
7+
const f = Array.from({ length: n * 2 - 1 }, () =>
8+
Array.from({ length: n }, () => Array.from({ length: n }, () => -Infinity)),
9+
);
10+
f[0][0][0] = grid[0][0];
1511
for (let k = 1; k < n * 2 - 1; ++k) {
1612
for (let i1 = 0; i1 < n; ++i1) {
1713
for (let i2 = 0; i2 < n; ++i2) {
18-
const j1 = k - i1,
19-
j2 = k - i2;
14+
const [j1, j2] = [k - i1, k - i2];
2015
if (
2116
j1 < 0 ||
2217
j1 >= n ||
@@ -27,19 +22,16 @@ var cherryPickup = function (grid) {
2722
) {
2823
continue;
2924
}
30-
let t = grid[i1][j1];
31-
if (i1 != i2) {
32-
t += grid[i2][j2];
33-
}
25+
const t = grid[i1][j1] + (i1 != i2 ? grid[i2][j2] : 0);
3426
for (let x1 = i1 - 1; x1 <= i1; ++x1) {
3527
for (let x2 = i2 - 1; x2 <= i2; ++x2) {
3628
if (x1 >= 0 && x2 >= 0) {
37-
dp[k][i1][i2] = Math.max(dp[k][i1][i2], dp[k - 1][x1][x2] + t);
29+
f[k][i1][i2] = Math.max(f[k][i1][i2], f[k - 1][x1][x2] + t);
3830
}
3931
}
4032
}
4133
}
4234
}
4335
}
44-
return Math.max(0, dp[n * 2 - 2][n - 1][n - 1]);
36+
return Math.max(0, f[n * 2 - 2][n - 1][n - 1]);
4537
};

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

+4-6
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,8 @@
11
class Solution:
22
def cherryPickup(self, grid: List[List[int]]) -> int:
33
n = len(grid)
4-
dp = [[[-inf] * n for _ in range(n)] for _ in range((n << 1) - 1)]
5-
dp[0][0][0] = grid[0][0]
4+
f = [[[-inf] * n for _ in range(n)] for _ in range((n << 1) - 1)]
5+
f[0][0][0] = grid[0][0]
66
for k in range(1, (n << 1) - 1):
77
for i1 in range(n):
88
for i2 in range(n):
@@ -20,7 +20,5 @@ def cherryPickup(self, grid: List[List[int]]) -> int:
2020
for x1 in range(i1 - 1, i1 + 1):
2121
for x2 in range(i2 - 1, i2 + 1):
2222
if x1 >= 0 and x2 >= 0:
23-
dp[k][i1][i2] = max(
24-
dp[k][i1][i2], dp[k - 1][x1][x2] + t
25-
)
26-
return max(0, dp[-1][-1][-1])
23+
f[k][i1][i2] = max(f[k][i1][i2], f[k - 1][x1][x2] + t)
24+
return max(0, f[-1][-1][-1])

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

+33
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
1+
function cherryPickup(grid: number[][]): number {
2+
const n: number = grid.length;
3+
const f: number[][][] = Array.from({ length: n * 2 - 1 }, () =>
4+
Array.from({ length: n }, () => Array.from({ length: n }, () => -Infinity)),
5+
);
6+
f[0][0][0] = grid[0][0];
7+
for (let k = 1; k < n * 2 - 1; ++k) {
8+
for (let i1 = 0; i1 < n; ++i1) {
9+
for (let i2 = 0; i2 < n; ++i2) {
10+
const [j1, j2]: [number, number] = [k - i1, k - i2];
11+
if (
12+
j1 < 0 ||
13+
j1 >= n ||
14+
j2 < 0 ||
15+
j2 >= n ||
16+
grid[i1][j1] == -1 ||
17+
grid[i2][j2] == -1
18+
) {
19+
continue;
20+
}
21+
const t: number = grid[i1][j1] + (i1 != i2 ? grid[i2][j2] : 0);
22+
for (let x1 = i1 - 1; x1 <= i1; ++x1) {
23+
for (let x2 = i2 - 1; x2 <= i2; ++x2) {
24+
if (x1 >= 0 && x2 >= 0) {
25+
f[k][i1][i2] = Math.max(f[k][i1][i2], f[k - 1][x1][x2] + t);
26+
}
27+
}
28+
}
29+
}
30+
}
31+
}
32+
return Math.max(0, f[n * 2 - 2][n - 1][n - 1]);
33+
}

0 commit comments

Comments
 (0)
Please sign in to comment.