3677. Maximum Amount Of Money Robot Can Earn¶
Difficulty: Medium
LeetCode Problem View on GitHub
3677. Maximum Amount of Money Robot Can Earn
Medium
You are given an m x n grid. A robot starts at the top-left corner of the grid (0, 0) and wants to reach the bottom-right corner (m - 1, n - 1). The robot can move either right or down at any point in time.
The grid contains a value coins[i][j] in each cell:
- If
coins[i][j] >= 0, the robot gains that many coins. - If
coins[i][j] < 0, the robot encounters a robber, and the robber steals the absolute value ofcoins[i][j]coins.
The robot has a special ability to neutralize robbers in at most 2 cells on its path, preventing them from stealing coins in those cells.
Note: The robot's total coins can be negative.
Return the maximum profit the robot can gain on the route.
Example 1:
Input: coins = [[0,1,-1],[1,-2,3],[2,-3,4]]
Output: 8
Explanation:
An optimal path for maximum coins is:
- Start at
(0, 0)with0coins (total coins =0). - Move to
(0, 1), gaining1coin (total coins =0 + 1 = 1). - Move to
(1, 1), where there's a robber stealing2coins. The robot uses one neutralization here, avoiding the robbery (total coins =1). - Move to
(1, 2), gaining3coins (total coins =1 + 3 = 4). - Move to
(2, 2), gaining4coins (total coins =4 + 4 = 8).
Example 2:
Input: coins = [[10,10,10],[10,10,10]]
Output: 40
Explanation:
An optimal path for maximum coins is:
- Start at
(0, 0)with10coins (total coins =10). - Move to
(0, 1), gaining10coins (total coins =10 + 10 = 20). - Move to
(0, 2), gaining another10coins (total coins =20 + 10 = 30). - Move to
(1, 2), gaining the final10coins (total coins =30 + 10 = 40).
Constraints:
m == coins.lengthn == coins[i].length1 <= m, n <= 500-1000 <= coins[i][j] <= 1000
Solution¶
class Solution {
private int dp[][][];
public int maximumAmount(int[][] coins) {
int n = coins.length, m = coins[0].length;
dp = new int[n + 1][m + 1][3];
for (int current[][] : dp) for (int current1[] : current) Arrays.fill(current1, (int)(-1e9));
return solve(0, 0, 2, coins);
}
private int solve(int row, int col, int power, int grid[][]) {
if (row < 0 || col < 0 || row >= grid.length || col >= grid[0].length) return Integer.MIN_VALUE / 10;
if (dp[row][col][power] != (int)(-1e9)) return dp[row][col][power];
if (row == grid.length - 1 && col == grid[0].length - 1) {
if (grid[row][col] > 0) return grid[row][col];
else if (power > 0) return 0;
else return grid[row][col];
}
if (grid[row][col] >= 0) {
int op1 = Integer.MIN_VALUE / 10, op2 = Integer.MIN_VALUE / 10;
op1 = grid[row][col] + Math.max(solve(row, col + 1, power, grid), solve(row + 1, col, power, grid));
return dp[row][col][power] = op1;
}
else {
int op1 = Integer.MIN_VALUE / 10, op2 = Integer.MIN_VALUE / 10;
if (power > 0) {
op1 = grid[row][col] + Math.max(solve(row, col + 1, power, grid), solve(row + 1, col, power, grid));
op2 = 0 + Math.max(solve(row, col + 1, power - 1, grid), solve(row + 1, col, power - 1, grid));
return dp[row][col][power] = Math.max(op1, op2);
}
return dp[row][col][power] = grid[row][col] + Math.max(solve(row, col + 1, power, grid), solve(row + 1, col, power, grid));
}
}
}
Complexity Analysis¶
- Time Complexity:
O(?) - Space Complexity:
O(?)
Approach¶
Detailed explanation of the approach will be added here