Python3 ||  13 lines, top-down dp, w/ example  || 99% / 91%
Here's an explanation by example.The plan is to use dynamic programming by overwriting coins with tuples each of length three, representing the the  best values
Here's an explanation by example.

The plan is to use dynamic programming by overwriting *coins* with tuples each of length three, representing the the  best values for each of three states, in which the number of unused *neutralizations* is zero, one, or two, respectively.  

We use Problem 1 in the description:
```
                    [[0,  1, -1],
           coins =   [1, -2,  3],
                     [2, -3,  4]]

```
1. We initialize the upper-left corner with its tuple:
```
                    [[(0,  0,  0),  1, -1],
           coins =   [          1, -2,  3],
                     [          2, -3,  4]]
```
2. We complete the first row using the function *dp*:
```
                    [[(0,  0,  0), (1, 1,  1), (1, 1, 0)],
           coins =   [          1,         -2,        3 ],
                     [          2,         -3,         4]]
```
3. We use *dp* to complete the modification of *coins*

```
                    [[(0,  0,  0), (1, 1,  1), (1, 1, 0)], 
           coins =   [(1,  1,  1), (1, 1, -1), (4, 4, 3)], 
                     [(3,  3,  3), (3, 3,  0), (8, 8, 7) <-- coins[-1][-1]]]
```
4. We return the maximum value of `coins[-1][-1]`.
```
            return  max((8, 8, 7)) = 8
```
____

Here's the code:

```python3 []
class Solution:
    def maximumAmount(self, coins: List[List[int]]) -> int:

        dp = lambda v, x: (max(v + x[0], x[1]), max(v + x[1], x[2]), v + x[2])

        m, n = len(coins), len(coins[0])
        coins[0][0] = (0, 0, coins[0][0])                       # <-- 1)

        for col in range(1,n):                                  # <-- 2)
            coins[0][col] = dp(coins[0][col], coins[0][col-1])

        for row in range(1,m):                                  # <-- 3)
            coins[row][0] = dp(coins[row][0], coins[row-1][0])

            for col in range(1,n):
                uppr0, uppr1, uppr2 = coins[row-1][col]
                left0, left1, left2 = coins[row][col-1]
                best = (max(uppr0, left0), max(uppr1, left1), max(uppr2, left2))

                coins[row][col] = dp(coins[row][col], best)
        
        return max(coins[-1][-1])                               # <-- 4)
```

[https://leetcode.com/problems/maximum-amount-of-money-robot-can-earn/submissions/1509589747/](https://leetcode.com/problems/maximum-amount-of-money-robot-can-earn/submissions/1509589747/)

I could be wrong, but I think that time complexity is *O*(*MN*) and space complexity is *O*(*MN*), in which *M, N* ~ `m, n`.
['Python3']