Maximum Amount of Money Robot Can Earn - Problem

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.

Input & Output

Example 1 — Basic Grid

$ Input: coins = [[1, -3], [2, -4]]

› Output: 3

💡 Note: Robot path: (0,0) → (1,0) → (1,1). Collect 1 + 2 = 3 coins, then use shield to neutralize -4 robber. Total: 3 coins.

Example 2 — All Positive

$ Input: coins = [[1, 2], [3, 4]]

› Output: 10

💡 Note: No robbers present. Best path: (0,0) → (0,1) → (1,1) gives 1 + 2 + 4 = 7, or (0,0) → (1,0) → (1,1) gives 1 + 3 + 4 = 8. Wait, let me recalculate: path (0,0) → (1,0) → (1,1) = 1 + 3 + 4 = 8.

Example 3 — Multiple Robbers

$ Input: coins = [[-1, -2], [-3, -4]]

› Output: -4

💡 Note: All cells have robbers. Best strategy: use 2 shields on the least negative cells. Path (0,0) → (0,1) → (1,1): neutralize -1 and -2, take -4. Total: 0 + 0 + (-4) = -4.

Constraints

1 ≤ m, n ≤ 50
-100 ≤ coins[i][j] ≤ 100
Robot can neutralize at most 2 robbers

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Facebook 12

The key insight is to use dynamic programming with an extra dimension to track remaining shields. We maintain a 3D DP table where dp[i][j][k] represents the maximum coins when reaching position (i,j) with k shields remaining. The optimal approach uses 3D DP with time complexity O(m×n) and space complexity O(m×n).

Common Approaches

✓ Sort First

⏱️ Time: N/A Space: N/A

3D Dynamic Programming

⏱️ Time: O(m×n) Space: O(m×n)

Build a 3D DP table where dp[i][j][k] represents the maximum coins when reaching cell (i,j) with k shields remaining. Fill the table bottom-up from destination to start.

Brute Force with Backtracking

⏱️ Time: O(2^(m×n)) Space: O(m+n)

Use recursive backtracking to explore every possible path from top-left to bottom-right. For each negative cell encountered, try both neutralizing and not neutralizing it (if shields remain).

Memoization (Top-Down DP)

⏱️ Time: O(m×n×3) Space: O(m×n×3)

Use recursive approach with memoization to store results of each state (position + shields remaining). This eliminates redundant calculations when the same state is reached via different paths.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

int max(int a, int b) {
    return a > b ? a : b;
}

int parseGrid(char* input, int grid[][50], int* m, int* n) {
    *m = 0;
    *n = 0;
    
    // Remove newline
    input[strcspn(input, "\n")] = 0;
    
    char* ptr = input;
    // Skip to first '['
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr != '[') return -1;
    ptr++; // skip '['
    
    int row = 0;
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++; // skip '['
            int col = 0;
            while (*ptr && *ptr != ']') {
                while (*ptr == ' ' || *ptr == ',') ptr++;
                if (*ptr == ']') break;
                
                // Parse number
                char* endptr;
                grid[row][col] = (int)strtol(ptr, &endptr, 10);
                ptr = endptr;
                col++;
            }
            if (*n == 0) *n = col;
            if (*ptr == ']') ptr++;
            row++;
        } else {
            ptr++;
        }
        while (*ptr == ',' || *ptr == ' ') ptr++;
    }
    *m = row;
    return 0;
}

int solve(int grid[][50], int m, int n) {
    // dp[i][j][k] = maximum coins at (i,j) using k shields
    int dp[50][50][3];
    
    // Initialize with very negative values
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            for (int k = 0; k <= 2; k++) {
                dp[i][j][k] = INT_MIN;
            }
        }
    }
    
    // Base case: starting position
    if (grid[0][0] >= 0) {
        dp[0][0][0] = grid[0][0];
        dp[0][0][1] = grid[0][0];
        dp[0][0][2] = grid[0][0];
    } else {
        dp[0][0][0] = grid[0][0]; // take the negative value
        dp[0][0][1] = 0; // use shield
        dp[0][0][2] = 0; // use shield
    }
    
    // Fill the DP table
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (i == 0 && j == 0) continue;
            
            for (int shields = 0; shields <= 2; shields++) {
                int maxPrev = INT_MIN;
                
                // From top
                if (i > 0 && dp[i-1][j][shields] != INT_MIN) {
                    maxPrev = max(maxPrev, dp[i-1][j][shields]);
                }
                
                // From left
                if (j > 0 && dp[i][j-1][shields] != INT_MIN) {
                    maxPrev = max(maxPrev, dp[i][j-1][shields]);
                }
                
                if (maxPrev != INT_MIN) {
                    dp[i][j][shields] = maxPrev + grid[i][j];
                }
                
                // Try using a shield if we have one and current cell is negative
                if (shields > 0 && grid[i][j] < 0) {
                    int maxPrevWithOneMoreShield = INT_MIN;
                    
                    // From top with one less shield used
                    if (i > 0 && dp[i-1][j][shields-1] != INT_MIN) {
                        maxPrevWithOneMoreShield = max(maxPrevWithOneMoreShield, dp[i-1][j][shields-1]);
                    }
                    
                    // From left with one less shield used
                    if (j > 0 && dp[i][j-1][shields-1] != INT_MIN) {
                        maxPrevWithOneMoreShield = max(maxPrevWithOneMoreShield, dp[i][j-1][shields-1]);
                    }
                    
                    if (maxPrevWithOneMoreShield != INT_MIN) {
                        dp[i][j][shields] = max(dp[i][j][shields], maxPrevWithOneMoreShield + 0); // neutralize robber
                    }
                }
            }
        }
    }
    
    // Return the maximum among all shield states at destination
    int result = dp[m-1][n-1][0];
    result = max(result, dp[m-1][n-1][1]);
    result = max(result, dp[m-1][n-1][2]);
    
    return result;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    int grid[50][50];
    int m, n;
    
    if (parseGrid(input, grid, &m, &n) != 0) {
        return -1;
    }
    
    int result = solve(grid, m, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.4K Views

Medium Frequency

~35 min Avg. Time

856 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen