Skip to content

Commit 5524e1d

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1463
No.1463.Cherry Pickup II
1 parent e0f93e8 commit 5524e1d

File tree

6 files changed

+457
-2
lines changed

6 files changed

+457
-2
lines changed

‎solution/1400-1499/1463.Cherry Pickup II/README.md

Lines changed: 158 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -73,22 +73,179 @@
7373

7474
<!-- 这里可写通用的实现逻辑 -->
7575

76+
**方法一：动态规划**
77+
78+
线性 DP。
79+
7680
<!-- tabs:start -->
7781

7882
### **Python3**
7983

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

8286
```python
83-
87+
class Solution:
88+
def cherryPickup(self, grid: List[List[int]]) -> int:
89+
m, n = len(grid), len(grid[0])
90+
dp = [[[0] * n for _ in range(n)] for _ in range(m)]
91+
valid = [[[False] * n for _ in range(n)] for _ in range(m)]
92+
dp[0][0][n - 1] = grid[0][0] + grid[0][n - 1]
93+
valid[0][0][n - 1] = True
94+
for i in range(1, m):
95+
for j1 in range(n):
96+
for j2 in range(n):
97+
t = grid[i][j1]
98+
if j1 != j2:
99+
t += grid[i][j2]
100+
ok = False
101+
for y1 in range(j1 - 1, j1 + 2):
102+
for y2 in range(j2 - 1, j2 + 2):
103+
if 0 <= y1 < n and 0 <= y2 < n and valid[i - 1][y1][y2]:
104+
dp[i][j1][j2] = max(
105+
dp[i][j1][j2], dp[i - 1][y1][y2] + t)
106+
ok = True
107+
valid[i][j1][j2] = ok
108+
return max(dp[m - 1][j1][j2] for j1 in range(n) for j2 in range(n))
84109
```
85110

86111
### **Java**
87112

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

90115
```java
116+
class Solution {
117+
public int cherryPickup(int[][] grid) {
118+
int m = grid.length;
119+
int n = grid[0].length;
120+
121+
int[][][] dp = new int[m][n][n];
122+
boolean[][][] valid = new boolean[m][n][n];
123+
dp[0][0][n - 1] = grid[0][0] + grid[0][n - 1];
124+
valid[0][0][n - 1] = true;
125+
126+
for (int i = 1; i < m; ++i) {
127+
for (int j1 = 0; j1 < n; ++j1) {
128+
for (int j2 = 0; j2 < n; ++j2) {
129+
int t = grid[i][j1];
130+
if (j1 != j2) {
131+
t += grid[i][j2];
132+
}
133+
boolean ok = false;
134+
for (int y1 = j1 - 1; y1 <= j1 + 1; ++y1) {
135+
for (int y2 = j2 - 1; y2 <= j2 + 1; ++y2) {
136+
if (y1 >= 0 && y1 < n && y2 >= 0 && y2 < n && valid[i - 1][y1][y2]) {
137+
dp[i][j1][j2] = Math.max(dp[i][j1][j2], dp[i - 1][y1][y2] + t);
138+
ok = true;
139+
}
140+
}
141+
}
142+
valid[i][j1][j2] = ok;
143+
}
144+
}
145+
}
146+
int ans = 0;
147+
for (int j1 = 0; j1 < n; ++j1) {
148+
for (int j2 = 0; j2 < n; ++j2) {
149+
ans = Math.max(ans, dp[m - 1][j1][j2]);
150+
}
151+
}
152+
return ans;
153+
}
154+
}
155+
```
156+
157+
### **C++**
158+
159+
```cpp
160+
class Solution {
161+
public:
162+
int cherryPickup(vector<vector<int>>& grid) {
163+
int m = grid.size(), n = grid[0].size();
164+
vector<vector<vector<int>>> dp(m, vector<vector<int>>(n, vector<int>(n)));
165+
vector<vector<vector<bool>>> valid(m, vector<vector<bool>>(n, vector<bool>(n)));
166+
dp[0][0][n - 1] = grid[0][0] + grid[0][n - 1];
167+
valid[0][0][n - 1] = true;
168+
for (int i = 1; i < m; ++i)
169+
{
170+
for (int j1 = 0; j1 < n; ++j1)
171+
{
172+
for (int j2 = 0; j2 < n; ++j2)
173+
{
174+
int t = grid[i][j1];
175+
if (j1 != j2) t += grid[i][j2];
176+
bool ok = false;
177+
for (int y1 = j1 - 1; y1 <= j1 + 1; ++y1)
178+
for (int y2 = j2 - 1; y2 <= j2 + 1; ++y2)
179+
if (y1 >= 0 && y1 < n && y2 >= 0 && y2 < n && valid[i - 1][y1][y2])
180+
{
181+
dp[i][j1][j2] = max(dp[i][j1][j2], dp[i - 1][y1][y2] + t);
182+
ok = true;
183+
}
184+
valid[i][j1][j2] = ok;
185+
}
186+
}
187+
}
188+
int ans = 0;
189+
for (int j1 = 0; j1 < n; ++j1)
190+
for (int j2 = 0; j2 < n; ++j2)
191+
ans = max(ans, dp[m - 1][j1][j2]);
192+
return ans;
193+
}
194+
};
195+
```
91196
197+
### **Go**
198+
199+
```go
200+
func cherryPickup(grid [][]int) int {
201+
m, n := len(grid), len(grid[0])
202+
dp := make([][][]int, m)
203+
valid := make([][][]bool, m)
204+
for i := range dp {
205+
dp[i] = make([][]int, n)
206+
valid[i] = make([][]bool, n)
207+
for j1 := range dp[i] {
208+
dp[i][j1] = make([]int, n)
209+
valid[i][j1] = make([]bool, n)
210+
}
211+
}
212+
dp[0][0][n-1] = grid[0][0] + grid[0][n-1]
213+
valid[0][0][n-1] = true
214+
for i := 1; i < m; i++ {
215+
for j1 := 0; j1 < n; j1++ {
216+
for j2 := 0; j2 < n; j2++ {
217+
t := grid[i][j1]
218+
if j1 != j2 {
219+
t += grid[i][j2]
220+
}
221+
ok := false
222+
for y1 := j1 - 1; y1 <= j1+1; y1++ {
223+
for y2 := j2 - 1; y2 <= j2+1; y2++ {
224+
if y1 >= 0 && y1 < n && y2 >= 0 && y2 < n && valid[i-1][y1][y2] {
225+
dp[i][j1][j2] = max(dp[i][j1][j2], dp[i-1][y1][y2]+t)
226+
ok = true
227+
}
228+
}
229+
}
230+
valid[i][j1][j2] = ok
231+
}
232+
}
233+
}
234+
ans := 0
235+
for j1 := 0; j1 < n; j1++ {
236+
for j2 := 0; j2 < n; j2++ {
237+
ans = max(ans, dp[m-1][j1][j2])
238+
}
239+
}
240+
return ans
241+
}
242+
243+
func max(a, b int) int {
244+
if a > b {
245+
return a
246+
}
247+
return b
248+
}
92249
```
93250

94251
### **...**

‎solution/1400-1499/1463.Cherry Pickup II/README_EN.md

Lines changed: 154 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -63,13 +63,166 @@ Total of cherries: 17 + 11 = 28.
6363
### **Python3**
6464

6565
```python
66-
66+
class Solution:
67+
def cherryPickup(self, grid: List[List[int]]) -> int:
68+
m, n = len(grid), len(grid[0])
69+
dp = [[[0] * n for _ in range(n)] for _ in range(m)]
70+
valid = [[[False] * n for _ in range(n)] for _ in range(m)]
71+
dp[0][0][n - 1] = grid[0][0] + grid[0][n - 1]
72+
valid[0][0][n - 1] = True
73+
for i in range(1, m):
74+
for j1 in range(n):
75+
for j2 in range(n):
76+
t = grid[i][j1]
77+
if j1 != j2:
78+
t += grid[i][j2]
79+
ok = False
80+
for y1 in range(j1 - 1, j1 + 2):
81+
for y2 in range(j2 - 1, j2 + 2):
82+
if 0 <= y1 < n and 0 <= y2 < n and valid[i - 1][y1][y2]:
83+
dp[i][j1][j2] = max(
84+
dp[i][j1][j2], dp[i - 1][y1][y2] + t)
85+
ok = True
86+
valid[i][j1][j2] = ok
87+
return max(dp[m - 1][j1][j2] for j1 in range(n) for j2 in range(n))
6788
```
6889

6990
### **Java**
7091

7192
```java
93+
class Solution {
94+
public int cherryPickup(int[][] grid) {
95+
int m = grid.length;
96+
int n = grid[0].length;
97+
98+
int[][][] dp = new int[m][n][n];
99+
boolean[][][] valid = new boolean[m][n][n];
100+
dp[0][0][n - 1] = grid[0][0] + grid[0][n - 1];
101+
valid[0][0][n - 1] = true;
102+
103+
for (int i = 1; i < m; ++i) {
104+
for (int j1 = 0; j1 < n; ++j1) {
105+
for (int j2 = 0; j2 < n; ++j2) {
106+
int t = grid[i][j1];
107+
if (j1 != j2) {
108+
t += grid[i][j2];
109+
}
110+
boolean ok = false;
111+
for (int y1 = j1 - 1; y1 <= j1 + 1; ++y1) {
112+
for (int y2 = j2 - 1; y2 <= j2 + 1; ++y2) {
113+
if (y1 >= 0 && y1 < n && y2 >= 0 && y2 < n && valid[i - 1][y1][y2]) {
114+
dp[i][j1][j2] = Math.max(dp[i][j1][j2], dp[i - 1][y1][y2] + t);
115+
ok = true;
116+
}
117+
}
118+
}
119+
valid[i][j1][j2] = ok;
120+
}
121+
}
122+
}
123+
int ans = 0;
124+
for (int j1 = 0; j1 < n; ++j1) {
125+
for (int j2 = 0; j2 < n; ++j2) {
126+
ans = Math.max(ans, dp[m - 1][j1][j2]);
127+
}
128+
}
129+
return ans;
130+
}
131+
}
132+
```
133+
134+
### **C++**
135+
136+
```cpp
137+
class Solution {
138+
public:
139+
int cherryPickup(vector<vector<int>>& grid) {
140+
int m = grid.size(), n = grid[0].size();
141+
vector<vector<vector<int>>> dp(m, vector<vector<int>>(n, vector<int>(n)));
142+
vector<vector<vector<bool>>> valid(m, vector<vector<bool>>(n, vector<bool>(n)));
143+
dp[0][0][n - 1] = grid[0][0] + grid[0][n - 1];
144+
valid[0][0][n - 1] = true;
145+
for (int i = 1; i < m; ++i)
146+
{
147+
for (int j1 = 0; j1 < n; ++j1)
148+
{
149+
for (int j2 = 0; j2 < n; ++j2)
150+
{
151+
int t = grid[i][j1];
152+
if (j1 != j2) t += grid[i][j2];
153+
bool ok = false;
154+
for (int y1 = j1 - 1; y1 <= j1 + 1; ++y1)
155+
for (int y2 = j2 - 1; y2 <= j2 + 1; ++y2)
156+
if (y1 >= 0 && y1 < n && y2 >= 0 && y2 < n && valid[i - 1][y1][y2])
157+
{
158+
dp[i][j1][j2] = max(dp[i][j1][j2], dp[i - 1][y1][y2] + t);
159+
ok = true;
160+
}
161+
valid[i][j1][j2] = ok;
162+
}
163+
}
164+
}
165+
int ans = 0;
166+
for (int j1 = 0; j1 < n; ++j1)
167+
for (int j2 = 0; j2 < n; ++j2)
168+
ans = max(ans, dp[m - 1][j1][j2]);
169+
return ans;
170+
}
171+
};
172+
```
72173
174+
### **Go**
175+
176+
```go
177+
func cherryPickup(grid [][]int) int {
178+
m, n := len(grid), len(grid[0])
179+
dp := make([][][]int, m)
180+
valid := make([][][]bool, m)
181+
for i := range dp {
182+
dp[i] = make([][]int, n)
183+
valid[i] = make([][]bool, n)
184+
for j1 := range dp[i] {
185+
dp[i][j1] = make([]int, n)
186+
valid[i][j1] = make([]bool, n)
187+
}
188+
}
189+
dp[0][0][n-1] = grid[0][0] + grid[0][n-1]
190+
valid[0][0][n-1] = true
191+
for i := 1; i < m; i++ {
192+
for j1 := 0; j1 < n; j1++ {
193+
for j2 := 0; j2 < n; j2++ {
194+
t := grid[i][j1]
195+
if j1 != j2 {
196+
t += grid[i][j2]
197+
}
198+
ok := false
199+
for y1 := j1 - 1; y1 <= j1+1; y1++ {
200+
for y2 := j2 - 1; y2 <= j2+1; y2++ {
201+
if y1 >= 0 && y1 < n && y2 >= 0 && y2 < n && valid[i-1][y1][y2] {
202+
dp[i][j1][j2] = max(dp[i][j1][j2], dp[i-1][y1][y2]+t)
203+
ok = true
204+
}
205+
}
206+
}
207+
valid[i][j1][j2] = ok
208+
}
209+
}
210+
}
211+
ans := 0
212+
for j1 := 0; j1 < n; j1++ {
213+
for j2 := 0; j2 < n; j2++ {
214+
ans = max(ans, dp[m-1][j1][j2])
215+
}
216+
}
217+
return ans
218+
}
219+
220+
func max(a, b int) int {
221+
if a > b {
222+
return a
223+
}
224+
return b
225+
}
73226
```
74227

75228
### **...**

‎solution/1400-1499/1463.Cherry Pickup II/Solution.cpp

Lines changed: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,35 @@
1+
class Solution {
2+
public:
3+
int cherryPickup(vector<vector<int>>& grid) {
4+
int m = grid.size(), n = grid[0].size();
5+
vector<vector<vector<int>>> dp(m, vector<vector<int>>(n, vector<int>(n)));
6+
vector<vector<vector<bool>>> valid(m, vector<vector<bool>>(n, vector<bool>(n)));
7+
dp[0][0][n - 1] = grid[0][0] + grid[0][n - 1];
8+
valid[0][0][n - 1] = true;
9+
for (int i = 1; i < m; ++i)
10+
{
11+
for (int j1 = 0; j1 < n; ++j1)
12+
{
13+
for (int j2 = 0; j2 < n; ++j2)
14+
{
15+
int t = grid[i][j1];
16+
if (j1 != j2) t += grid[i][j2];
17+
bool ok = false;
18+
for (int y1 = j1 - 1; y1 <= j1 + 1; ++y1)
19+
for (int y2 = j2 - 1; y2 <= j2 + 1; ++y2)
20+
if (y1 >= 0 && y1 < n && y2 >= 0 && y2 < n && valid[i - 1][y1][y2])
21+
{
22+
dp[i][j1][j2] = max(dp[i][j1][j2], dp[i - 1][y1][y2] + t);
23+
ok = true;
24+
}
25+
valid[i][j1][j2] = ok;
26+
}
27+
}
28+
}
29+
int ans = 0;
30+
for (int j1 = 0; j1 < n; ++j1)
31+
for (int j2 = 0; j2 < n; ++j2)
32+
ans = max(ans, dp[m - 1][j1][j2]);
33+
return ans;
34+
}
35+
};

0 commit comments

Comments
 (0)