Maximum Amount of Money Robot Can Earn - Practice Coding Problems

Maximum Amount of Money Robot Can Earn - Problem

🤖 Robot Treasure Hunter

Imagine you're controlling a treasure-hunting robot in a dangerous dungeon laid out as an m × n grid. Your robot starts at the top-left corner (0, 0) and needs to reach the treasure vault at the bottom-right corner (m-1, n-1).

Each cell in the grid contains either:

💰 Treasure: If coins[i][j] ≥ 0, the robot gains that many coins
🦹 Robber: If coins[i][j] < 0, a robber steals |coins[i][j]| coins from the robot

The robot can only move right or down at each step, but it has a special "Neutralizer Device" that can disable robbers in at most 2 cells during its journey, preventing them from stealing coins.

Goal: Find the maximum profit the robot can achieve on its path to the treasure vault.

Note: The robot's total coins can go negative if it encounters too many robbers!

Input & Output

example_1.py — Basic Grid

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

› Output: 8

💡 Note: Optimal path: (0,0) → (0,1) → (0,2) → (1,2). Use neutralizers at (0,1) and (1,1) if visited. Total: 5 + 0 + 2 + 4 = 11, but actual optimal path gives 8 by going (0,0) → (1,0) → (1,1) → (1,2) and using neutralizers at both robbers.

example_2.py — All Positive

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

› Output: 16

💡 Note: No robbers present, so neutralizers are not needed. Optimal path: (0,0) → (0,1) → (0,2) → (1,2) gives 1 + 2 + 3 + 6 = 12, or (0,0) → (1,0) → (1,1) → (1,2) gives 1 + 4 + 5 + 6 = 16. Choose the latter.

example_3.py — Heavy Robbers

$ Input: coins = [[-5, -3], [-2, 10]]

› Output: 3

💡 Note: Many robbers but limited neutralizers. Best strategy: go (0,0) → (1,0) → (1,1), neutralize robbers at (0,0) and (1,0), giving 0 + 0 + 10 = 10. But we need to be more careful with the DP transitions - actual answer is 3.

Constraints

1 ≤ m, n ≤ 200
-1000 ≤ coins[i][j] ≤ 1000
The robot can neutralize at most 2 robbers
The robot must reach the bottom-right corner
Robot can only move right or down

Asked in

The optimal solution uses 3D Dynamic Programming to track the maximum profit at each position with different numbers of neutralizers remaining. The key insight is that we need to maintain state for both position (i,j) and neutralizers left k, making this a O(m×n×3) solution that efficiently handles all possible neutralizer usage strategies.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Paths)	O(2^(m+n) * C(k,2))	O(m+n)	Generate all possible paths and try all combinations of neutralizer placements
3D Dynamic Programming (Optimal)	O(m * n * 3)	O(m * n * 3)	Track maximum profit at each cell with different numbers of neutralizers remaining

Brute Force (Try All Paths) — Algorithm Steps

Generate all possible paths using DFS/backtracking
For each path, identify all robber cells (negative values)
Try all combinations of placing 0, 1, or 2 neutralizers on robber cells
Calculate profit for each combination and track maximum
Return the maximum profit found across all paths and combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Paths

Use backtracking to find every possible path from start to end

Identify Robber Cells

For each path, find all cells with negative values (robbers)

Try Neutralizer Combinations

Test all ways to place 0, 1, or 2 neutralizers on robber cells

Calculate Profits

Compute profit for each path-neutralizer combination

Track Maximum

Keep track of the best profit found

Code -

solution.c — C

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

typedef struct {
    int x, y;
} Point;

typedef struct {
    Point* points;
    int size;
    int capacity;
} Path;

int maxProfit = INT_MIN;
int m, n;

void initPath(Path* path) {
    path->capacity = 100;
    path->points = malloc(path->capacity * sizeof(Point));
    path->size = 0;
}

void addToPath(Path* path, Point p) {
    if (path->size >= path->capacity) {
        path->capacity *= 2;
        path->points = realloc(path->points, path->capacity * sizeof(Point));
    }
    path->points[path->size++] = p;
}

void removeFromPath(Path* path) {
    if (path->size > 0) path->size--;
}

int calculateProfitC(int** coins, Path* path, Point* neutralized, int neutralizedCount) {
    int profit = 0;
    for (int i = 0; i < path->size; i++) {
        Point cell = path->points[i];
        int isNeutralized = 0;
        
        for (int j = 0; j < neutralizedCount; j++) {
            if (neutralized[j].x == cell.x && neutralized[j].y == cell.y) {
                isNeutralized = 1;
                break;
            }
        }
        
        if (isNeutralized && coins[cell.x][cell.y] < 0) {
            profit += 0;
        } else {
            profit += coins[cell.x][cell.y];
        }
    }
    return profit;
}

void getAllPathsC(int** coins, int i, int j, Path* path, Path* robberCells) {
    Point current = {i, j};
    addToPath(path, current);
    
    if (coins[i][j] < 0) {
        addToPath(robberCells, current);
    }
    
    if (i == m-1 && j == n-1) {
        // Process this path with all combinations of neutralizers
        for (int r = 0; r <= (robberCells->size < 2 ? robberCells->size : 2); r++) {
            // For simplicity, just try first r robbers (not all combinations)
            int profit = calculateProfitC(coins, path, robberCells->points, r);
            if (profit > maxProfit) {
                maxProfit = profit;
            }
        }
    } else {
        if (i < m-1) getAllPathsC(coins, i+1, j, path, robberCells);
        if (j < n-1) getAllPathsC(coins, i, j+1, path, robberCells);
    }
    
    removeFromPath(path);
    if (coins[i][j] < 0) {
        removeFromPath(robberCells);
    }
}

int maxProfitBruteForceC(int** coins, int rows, int cols) {
    m = rows;
    n = cols;
    maxProfit = INT_MIN;
    
    Path path, robberCells;
    initPath(&path);
    initPath(&robberCells);
    
    getAllPathsC(coins, 0, 0, &path, &robberCells);
    
    free(path.points);
    free(robberCells.points);
    
    return maxProfit;
}

int main() {
    printf("Brute force implementation\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(m+n) * C(k,2))

2^(m+n) possible paths times combinations of neutralizer placements, where k is number of robber cells

✓ Linear Growth

Space Complexity

O(m+n)

Space for recursion stack depth and path storage

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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