Skip to content

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 of coins[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:

  1. Start at (0, 0) with 0 coins (total coins = 0).
  2. Move to (0, 1), gaining 1 coin (total coins = 0 + 1 = 1).
  3. Move to (1, 1), where there's a robber stealing 2 coins. The robot uses one neutralization here, avoiding the robbery (total coins = 1).
  4. Move to (1, 2), gaining 3 coins (total coins = 1 + 3 = 4).
  5. Move to (2, 2), gaining 4 coins (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:

  1. Start at (0, 0) with 10 coins (total coins = 10).
  2. Move to (0, 1), gaining 10 coins (total coins = 10 + 10 = 20).
  3. Move to (0, 2), gaining another 10 coins (total coins = 20 + 10 = 30).
  4. Move to (1, 2), gaining the final 10 coins (total coins = 30 + 10 = 40).

 

Constraints:

  • m == coins.length
  • n == coins[i].length
  • 1 <= 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