Dynamic Programming Solution | C++ 
IntuitionApproachDefine a state and recurrence relation that accounts for the robot's ability to neutralize robbers in at most two cells.Complexity
Time complex
# Intuition
<!-- Describe your first thoughts on how to solve this problem. -->

# Approach
<!-- Describe your approach to solving the problem. -->
Define a state and recurrence relation that accounts for the robot's ability to neutralize robbers in at most two cells. 
# Complexity
- Time complexity:
<!-- Add your time complexity here, e.g. $$O(n)$$ -->
    O(m×n×3)=O(m×n), we compute the DP table for each cell and each robber-neutralization state.

- Space complexity:
<!-- Add your space complexity here, e.g. $$O(n)$$ -->
    O(m×n×3) for the DP table.
# Code
```cpp []
class Solution {
public:
    int maximumAmount(vector<vector<int>>& coins) {
        int m = coins.size();
        int n = coins[0].size();
        vector<vector<vector<int>>> dp(m, vector<vector<int>>(n, vector<int>(3, INT_MIN)));

        // Base case
        for (int k = 0; k < 3; k++) {
            dp[0][0][k] = coins[0][0] >= 0 ? coins[0][0] : (k > 0 ? 0 : coins[0][0]);
        }

        // DP Transition
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                for (int k = 0; k < 3; k++) {
                    if (i == 0 && j == 0) continue;

                    int currentValue = coins[i][j];
                    int neutralizeValue = (currentValue < 0 && k > 0) ? 0 : currentValue;

                    if (j > 0) { // From the left
                        dp[i][j][k] = max(dp[i][j][k], dp[i][j - 1][k] + currentValue);
                        if (currentValue < 0 && k > 0) {
                            dp[i][j][k] = max(dp[i][j][k], dp[i][j - 1][k - 1] + neutralizeValue);
                        }
                    }

                    if (i > 0) { // From above
                        dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j][k] + currentValue);
                        if (currentValue < 0 && k > 0) {
                            dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j][k - 1] + neutralizeValue);
                        }
                    }
                }
            }
        }

        // Find the maximum profit at the bottom-right corner
        return max({dp[m - 1][n - 1][0], dp[m - 1][n - 1][1], dp[m - 1][n - 1][2]});
    }
};
```
['Dynamic Programming', 'C++']