Skip to content

Commit 636aad9

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.3418 (#3946)
No.3418.Maximum Amount of Money Robot Can Earn
1 parent b8a26d3 commit 636aad9

File tree

7 files changed

+414
-8
lines changed

7 files changed

+414
-8
lines changed

‎solution/3400-3499/3418.Maximum Amount of Money Robot Can Earn/README.md

+143-4
Original file line numberDiff line numberDiff line change
@@ -87,32 +87,171 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3400-3499/3418.Ma
8787

8888
<!-- solution:start -->
8989

90-
### 方法一
90+
### 方法一：记忆化搜索
91+
92+
我们设计一个函数 $\textit{dfs}(i, j, k)$，表示机器人从 $(i, j)$ 出发，还剩下 $k$ 次感化机会时，能够获得的最大金币数。机器人只能向右或向下移动，因此 $\textit{dfs}(i, j, k)$ 的值只与 $\textit{dfs}(i + 1, j, k)$ 和 $\textit{dfs}(i, j + 1, k)$ 有关。
93+
94+
- 如果 $i \geq m$ 或 $j \geq n$，表示机器人走出了网格，此时返回一个极小值。
95+
- 如果 $i = m - 1$ 且 $j = n - 1$，表示机器人到达了网格的右下角，此时如果 $k > 0$，则机器人可以选择感化当前位置的强盗，因此返回 $\max(0, \textit{coins}[i][j])$；如果 $k = 0$，则机器人不能感化当前位置的强盗，因此返回 $\textit{coins}[i][j]$。
96+
- 如果 $\textit{coins}[i][j] < 0$，表示当前位置有强盗，此时如果 $k > 0$，则机器人可以选择感化当前位置的强盗，因此返回 $\textit{coins}[i][j] + \max(\textit{dfs}(i + 1, j, k), \textit{dfs}(i, j + 1, k))$；如果 $k = 0$，则机器人不能感化当前位置的强盗，因此返回 $\textit{coins}[i][j] + \max(\textit{dfs}(i + 1, j, k), \textit{dfs}(i, j + 1, k))$。
97+
98+
根据上述分析，我们可以编写出记忆化搜索的代码。
99+
100+
时间复杂度 $O(m \times n \times k)$，空间复杂度 $O(m \times n \times k)$。其中 $m$ 和 $n$ 分别是二维数组 $\textit{coins}$ 的行数和列数，而 $k$ 是感化机会的状态数，本题中 $k = 3$。
91101

92102
<!-- tabs:start -->
93103

94104
#### Python3
95105

96106
```python
97-
107+
class Solution:
108+
def maximumAmount(self, coins: List[List[int]]) -> int:
109+
@cache
110+
def dfs(i: int, j: int, k: int) -> int:
111+
if i >= m or j >= n:
112+
return -inf
113+
if i == m - 1 and j == n - 1:
114+
return max(coins[i][j], 0) if k else coins[i][j]
115+
ans = coins[i][j] + max(dfs(i + 1, j, k), dfs(i, j + 1, k))
116+
if coins[i][j] < 0 and k:
117+
ans = max(ans, dfs(i + 1, j, k - 1), dfs(i, j + 1, k - 1))
118+
return ans
119+
120+
m, n = len(coins), len(coins[0])
121+
return dfs(0, 0, 2)
98122
```
99123

100124
#### Java
101125

102126
```java
103-
127+
class Solution {
128+
private Integer[][][] f;
129+
private int[][] coins;
130+
private int m;
131+
private int n;
132+
133+
public int maximumAmount(int[][] coins) {
134+
m = coins.length;
135+
n = coins[0].length;
136+
this.coins = coins;
137+
f = new Integer[m][n][3];
138+
return dfs(0, 0, 2);
139+
}
140+
141+
private int dfs(int i, int j, int k) {
142+
if (i >= m || j >= n) {
143+
return Integer.MIN_VALUE / 2;
144+
}
145+
if (f[i][j][k] != null) {
146+
return f[i][j][k];
147+
}
148+
if (i == m - 1 && j == n - 1) {
149+
return k > 0 ? Math.max(0, coins[i][j]) : coins[i][j];
150+
}
151+
int ans = coins[i][j] + Math.max(dfs(i + 1, j, k), dfs(i, j + 1, k));
152+
if (coins[i][j] < 0 && k > 0) {
153+
ans = Math.max(ans, Math.max(dfs(i + 1, j, k - 1), dfs(i, j + 1, k - 1)));
154+
}
155+
return f[i][j][k] = ans;
156+
}
157+
}
104158
```
105159

106160
#### C++
107161

108162
```cpp
109-
163+
class Solution {
164+
public:
165+
int maximumAmount(vector<vector<int>>& coins) {
166+
int m = coins.size(), n = coins[0].size();
167+
vector<vector<vector<int>>> f(m, vector<vector<int>>(n, vector<int>(3, -1)));
168+
auto dfs = [&](this auto&& dfs, int i, int j, int k) -> int {
169+
if (i >= m || j >= n) {
170+
return INT_MIN / 2;
171+
}
172+
if (f[i][j][k] != -1) {
173+
return f[i][j][k];
174+
}
175+
if (i == m - 1 && j == n - 1) {
176+
return k > 0 ? max(0, coins[i][j]) : coins[i][j];
177+
}
178+
int ans = coins[i][j] + max(dfs(i + 1, j, k), dfs(i, j + 1, k));
179+
if (coins[i][j] < 0 && k > 0) {
180+
ans = max({ans, dfs(i + 1, j, k - 1), dfs(i, j + 1, k - 1)});
181+
}
182+
return f[i][j][k] = ans;
183+
};
184+
return dfs(0, 0, 2);
185+
}
186+
};
110187
```
111188
112189
#### Go
113190
114191
```go
192+
func maximumAmount(coins [][]int) int {
193+
m, n := len(coins), len(coins[0])
194+
f := make([][][]int, m)
195+
for i := range f {
196+
f[i] = make([][]int, n)
197+
for j := range f[i] {
198+
f[i][j] = make([]int, 3)
199+
for k := range f[i][j] {
200+
f[i][j][k] = math.MinInt32
201+
}
202+
}
203+
}
204+
var dfs func(i, j, k int) int
205+
dfs = func(i, j, k int) int {
206+
if i >= m || j >= n {
207+
return math.MinInt32 / 2
208+
}
209+
if f[i][j][k] != math.MinInt32 {
210+
return f[i][j][k]
211+
}
212+
if i == m-1 && j == n-1 {
213+
if k > 0 {
214+
return max(0, coins[i][j])
215+
}
216+
return coins[i][j]
217+
}
218+
ans := coins[i][j] + max(dfs(i+1, j, k), dfs(i, j+1, k))
219+
if coins[i][j] < 0 && k > 0 {
220+
ans = max(ans, max(dfs(i+1, j, k-1), dfs(i, j+1, k-1)))
221+
}
222+
f[i][j][k] = ans
223+
return ans
224+
}
225+
return dfs(0, 0, 2)
226+
}
227+
```
115228

229+
#### TypeScript
230+
231+
```ts
232+
function maximumAmount(coins: number[][]): number {
233+
const [m, n] = [coins.length, coins[0].length];
234+
const f = Array.from({ length: m }, () =>
235+
Array.from({ length: n }, () => Array(3).fill(-Infinity)),
236+
);
237+
const dfs = (i: number, j: number, k: number): number => {
238+
if (i >= m || j >= n) {
239+
return -Infinity;
240+
}
241+
if (f[i][j][k] !== -Infinity) {
242+
return f[i][j][k];
243+
}
244+
if (i === m - 1 && j === n - 1) {
245+
return k > 0 ? Math.max(0, coins[i][j]) : coins[i][j];
246+
}
247+
let ans = coins[i][j] + Math.max(dfs(i + 1, j, k), dfs(i, j + 1, k));
248+
if (coins[i][j] < 0 && k > 0) {
249+
ans = Math.max(ans, dfs(i + 1, j, k - 1), dfs(i, j + 1, k - 1));
250+
}
251+
return (f[i][j][k] = ans);
252+
};
253+
return dfs(0, 0, 2);
254+
}
116255
```
117256

118257
<!-- tabs:end -->

‎solution/3400-3499/3418.Maximum Amount of Money Robot Can Earn/README_EN.md

+143-4
Original file line numberDiff line numberDiff line change
@@ -85,32 +85,171 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3400-3499/3418.Ma
8585

8686
<!-- solution:start -->
8787

88-
### Solution 1
88+
### Solution 1: Memoized Search
89+
90+
We design a function $\textit{dfs}(i, j, k)$, which represents the maximum amount of coins the robot can collect starting from $(i, j)$ with $k$ conversion opportunities left. The robot can only move right or down, so the value of $\textit{dfs}(i, j, k)$ depends only on $\textit{dfs}(i + 1, j, k)$ and $\textit{dfs}(i, j + 1, k)$.
91+
92+
- If $i \geq m$ or $j \geq n$, it means the robot has moved out of the grid, so we return a very small value.
93+
- If $i = m - 1$ and $j = n - 1$, it means the robot has reached the bottom-right corner of the grid. If $k > 0$, the robot can choose to convert the bandit at the current position, so we return $\max(0, \textit{coins}[i][j])$. If $k = 0$, the robot cannot convert the bandit at the current position, so we return $\textit{coins}[i][j]$.
94+
- If $\textit{coins}[i][j] < 0$, it means there is a bandit at the current position. If $k > 0$, the robot can choose to convert the bandit at the current position, so we return $\textit{coins}[i][j] + \max(\textit{dfs}(i + 1, j, k), \textit{dfs}(i, j + 1, k))$. If $k = 0$, the robot cannot convert the bandit at the current position, so we return $\textit{coins}[i][j] + \max(\textit{dfs}(i + 1, j, k), \textit{dfs}(i, j + 1, k))$.
95+
96+
Based on the above analysis, we can write the code for memoized search.
97+
98+
The time complexity is $O(m \times n \times k)$, and the space complexity is $O(m \times n \times k)$. Here, $m$ and $n$ are the number of rows and columns of the 2D array $\textit{coins}$, and $k$ is the number of conversion opportunities, which is $3$ in this problem.
8999

90100
<!-- tabs:start -->
91101

92102
#### Python3
93103

94104
```python
95-
105+
class Solution:
106+
def maximumAmount(self, coins: List[List[int]]) -> int:
107+
@cache
108+
def dfs(i: int, j: int, k: int) -> int:
109+
if i >= m or j >= n:
110+
return -inf
111+
if i == m - 1 and j == n - 1:
112+
return max(coins[i][j], 0) if k else coins[i][j]
113+
ans = coins[i][j] + max(dfs(i + 1, j, k), dfs(i, j + 1, k))
114+
if coins[i][j] < 0 and k:
115+
ans = max(ans, dfs(i + 1, j, k - 1), dfs(i, j + 1, k - 1))
116+
return ans
117+
118+
m, n = len(coins), len(coins[0])
119+
return dfs(0, 0, 2)
96120
```
97121

98122
#### Java
99123

100124
```java
101-
125+
class Solution {
126+
private Integer[][][] f;
127+
private int[][] coins;
128+
private int m;
129+
private int n;
130+
131+
public int maximumAmount(int[][] coins) {
132+
m = coins.length;
133+
n = coins[0].length;
134+
this.coins = coins;
135+
f = new Integer[m][n][3];
136+
return dfs(0, 0, 2);
137+
}
138+
139+
private int dfs(int i, int j, int k) {
140+
if (i >= m || j >= n) {
141+
return Integer.MIN_VALUE / 2;
142+
}
143+
if (f[i][j][k] != null) {
144+
return f[i][j][k];
145+
}
146+
if (i == m - 1 && j == n - 1) {
147+
return k > 0 ? Math.max(0, coins[i][j]) : coins[i][j];
148+
}
149+
int ans = coins[i][j] + Math.max(dfs(i + 1, j, k), dfs(i, j + 1, k));
150+
if (coins[i][j] < 0 && k > 0) {
151+
ans = Math.max(ans, Math.max(dfs(i + 1, j, k - 1), dfs(i, j + 1, k - 1)));
152+
}
153+
return f[i][j][k] = ans;
154+
}
155+
}
102156
```
103157

104158
#### C++
105159

106160
```cpp
107-
161+
class Solution {
162+
public:
163+
int maximumAmount(vector<vector<int>>& coins) {
164+
int m = coins.size(), n = coins[0].size();
165+
vector<vector<vector<int>>> f(m, vector<vector<int>>(n, vector<int>(3, -1)));
166+
auto dfs = [&](this auto&& dfs, int i, int j, int k) -> int {
167+
if (i >= m || j >= n) {
168+
return INT_MIN / 2;
169+
}
170+
if (f[i][j][k] != -1) {
171+
return f[i][j][k];
172+
}
173+
if (i == m - 1 && j == n - 1) {
174+
return k > 0 ? max(0, coins[i][j]) : coins[i][j];
175+
}
176+
int ans = coins[i][j] + max(dfs(i + 1, j, k), dfs(i, j + 1, k));
177+
if (coins[i][j] < 0 && k > 0) {
178+
ans = max({ans, dfs(i + 1, j, k - 1), dfs(i, j + 1, k - 1)});
179+
}
180+
return f[i][j][k] = ans;
181+
};
182+
return dfs(0, 0, 2);
183+
}
184+
};
108185
```
109186
110187
#### Go
111188
112189
```go
190+
func maximumAmount(coins [][]int) int {
191+
m, n := len(coins), len(coins[0])
192+
f := make([][][]int, m)
193+
for i := range f {
194+
f[i] = make([][]int, n)
195+
for j := range f[i] {
196+
f[i][j] = make([]int, 3)
197+
for k := range f[i][j] {
198+
f[i][j][k] = math.MinInt32
199+
}
200+
}
201+
}
202+
var dfs func(i, j, k int) int
203+
dfs = func(i, j, k int) int {
204+
if i >= m || j >= n {
205+
return math.MinInt32 / 2
206+
}
207+
if f[i][j][k] != math.MinInt32 {
208+
return f[i][j][k]
209+
}
210+
if i == m-1 && j == n-1 {
211+
if k > 0 {
212+
return max(0, coins[i][j])
213+
}
214+
return coins[i][j]
215+
}
216+
ans := coins[i][j] + max(dfs(i+1, j, k), dfs(i, j+1, k))
217+
if coins[i][j] < 0 && k > 0 {
218+
ans = max(ans, max(dfs(i+1, j, k-1), dfs(i, j+1, k-1)))
219+
}
220+
f[i][j][k] = ans
221+
return ans
222+
}
223+
return dfs(0, 0, 2)
224+
}
225+
```
113226

227+
#### TypeScript
228+
229+
```ts
230+
function maximumAmount(coins: number[][]): number {
231+
const [m, n] = [coins.length, coins[0].length];
232+
const f = Array.from({ length: m }, () =>
233+
Array.from({ length: n }, () => Array(3).fill(-Infinity)),
234+
);
235+
const dfs = (i: number, j: number, k: number): number => {
236+
if (i >= m || j >= n) {
237+
return -Infinity;
238+
}
239+
if (f[i][j][k] !== -Infinity) {
240+
return f[i][j][k];
241+
}
242+
if (i === m - 1 && j === n - 1) {
243+
return k > 0 ? Math.max(0, coins[i][j]) : coins[i][j];
244+
}
245+
let ans = coins[i][j] + Math.max(dfs(i + 1, j, k), dfs(i, j + 1, k));
246+
if (coins[i][j] < 0 && k > 0) {
247+
ans = Math.max(ans, dfs(i + 1, j, k - 1), dfs(i, j + 1, k - 1));
248+
}
249+
return (f[i][j][k] = ans);
250+
};
251+
return dfs(0, 0, 2);
252+
}
114253
```
115254

116255
<!-- tabs:end -->

‎solution/3400-3499/3418.Maximum Amount of Money Robot Can Earn/Solution.cpp

+24
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
class Solution {
2+
public:
3+
int maximumAmount(vector<vector<int>>& coins) {
4+
int m = coins.size(), n = coins[0].size();
5+
vector<vector<vector<int>>> f(m, vector<vector<int>>(n, vector<int>(3, -1)));
6+
auto dfs = [&](this auto&& dfs, int i, int j, int k) -> int {
7+
if (i >= m || j >= n) {
8+
return INT_MIN / 2;
9+
}
10+
if (f[i][j][k] != -1) {
11+
return f[i][j][k];
12+
}
13+
if (i == m - 1 && j == n - 1) {
14+
return k > 0 ? max(0, coins[i][j]) : coins[i][j];
15+
}
16+
int ans = coins[i][j] + max(dfs(i + 1, j, k), dfs(i, j + 1, k));
17+
if (coins[i][j] < 0 && k > 0) {
18+
ans = max({ans, dfs(i + 1, j, k - 1), dfs(i, j + 1, k - 1)});
19+
}
20+
return f[i][j][k] = ans;
21+
};
22+
return dfs(0, 0, 2);
23+
}
24+
};

0 commit comments

Comments
 (0)