Java based solution ||  3D DP
IntuitionApproachComplexity
Time complexity:

Space complexity:
once u understand the state dp[i][j][k]=max coins robot can take from cell (i,j) -> cell (n-1,m-
# Intuition
<!-- Describe your first thoughts on how to solve this problem. -->

# Approach
<!-- Describe your approach to solving the problem. -->

# Complexity
- Time complexity:
<!-- Add your time complexity here, e.g. $$O(n)$$ -->O(n*m)

- Space complexity:
<!-- Add your space complexity here, e.g. $$O(n)$$ -->O(n*m)

once u understand the state dp[i][j][k]=max coins robot can take from cell (i,j) -> cell (n-1,m-1) while neutralizing upto k robbers the transition follows.

Code has comments for base case and transition.

# Code
```java []
class Solution {
    public int maximumAmount(int[][] coins) {
        return maxProfit(coins);
    }

    public int maxProfit(int[][] coins) {
        int m = coins.length;
        int n = coins[0].length;
        int maxNeutralize = 2;

        int[][][] dp = new int[m][n][maxNeutralize + 1];

        // Initialize with MIN_VALUE
        for (int[][] grid : dp) {
            for (int[] row : grid) {
                Arrays.fill(row, Integer.MIN_VALUE);
            }
        }

        // Initialize bottom-right corner
        for (int k = 0; k <= maxNeutralize; k++) {
            if (coins[m-1][n-1] >= 0) {
                dp[m-1][n-1][k] = coins[m-1][n-1];
            } else if (k > 0) {
                dp[m-1][n-1][k] = 0;
            } else {
                dp[m-1][n-1][k] = coins[m-1][n-1];
            }
        }

        for (int i = m - 1; i >= 0; i--) {
            for (int j = n - 1; j >= 0; j--) {
                if (i == m-1 && j == n-1) continue;
                
                for (int k = 0; k <= maxNeutralize; k++) {
                    // Try all possible moves from current position
                    if (coins[i][j] >= 0) {
                        // For positive or zero values, just add them
                        if (j + 1 < n && dp[i][j+1][k] != Integer.MIN_VALUE) {
                            dp[i][j][k] = Math.max(dp[i][j][k], coins[i][j] + dp[i][j+1][k]);
                        }
                        if (i + 1 < m && dp[i+1][j][k] != Integer.MIN_VALUE) {
                            dp[i][j][k] = Math.max(dp[i][j][k], coins[i][j] + dp[i+1][j][k]);
                        }
                    } else {
                        // For negative values (robbers)
                        // Option 1: Neutralize the robber if we have neutralizations left
                        if (k > 0) {
                            if (j + 1 < n && dp[i][j+1][k-1] != Integer.MIN_VALUE) {
                                dp[i][j][k] = Math.max(dp[i][j][k], dp[i][j+1][k-1]);
                            }
                            if (i + 1 < m && dp[i+1][j][k-1] != Integer.MIN_VALUE) {
                                dp[i][j][k] = Math.max(dp[i][j][k], dp[i+1][j][k-1]);
                            }
                        }
                        // Option 2: Don't neutralize and take the penalty
                        if (j + 1 < n && dp[i][j+1][k] != Integer.MIN_VALUE) {
                            dp[i][j][k] = Math.max(dp[i][j][k], coins[i][j] + dp[i][j+1][k]);
                        }
                        if (i + 1 < m && dp[i+1][j][k] != Integer.MIN_VALUE) {
                            dp[i][j][k] = Math.max(dp[i][j][k], coins[i][j] + dp[i+1][j][k]);
                        }
                    }
                }
            }
        }

        int result = Integer.MIN_VALUE;
        for (int k = 0; k <= maxNeutralize; k++) {
            result = Math.max(result, dp[0][0][k]);
        }
        
        return result == Integer.MIN_VALUE ? 0 : result;
    }
}
```
['Array', 'Dynamic Programming', 'Java']