# Solving Leetcode Interviews in Seconds with AI: Maximum Amount of Money Robot Can Earn


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "3418" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> 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.   Example 1:  Input: coins = [[0,1,-1],[1,-2,3],[2,-3,4]] Output: 8 Explanation: An optimal path for maximum coins is:  Start at (0, 0) with 0 coins (total coins = 0). Move to (0, 1), gaining 1 coin (total coins = 0 + 1 = 1). Move to (1, 1), where there's a robber stealing 2 coins. The robot uses one neutralization here, avoiding the robbery (total coins = 1). Move to (1, 2), gaining 3 coins (total coins = 1 + 3 = 4). Move to (2, 2), gaining 4 coins (total coins = 4 + 4 = 8).   Example 2:  Input: coins = [[10,10,10],[10,10,10]] Output: 40 Explanation: An optimal path for maximum coins is:  Start at (0, 0) with 10 coins (total coins = 10). Move to (0, 1), gaining 10 coins (total coins = 10 + 10 = 20). Move to (0, 2), gaining another 10 coins (total coins = 20 + 10 = 30). Move to (1, 2), gaining the final 10 coins (total coins = 30 + 10 = 40).     Constraints:  m == coins.length n == coins[i].length 1 <= m, n <= 500 -1000 <= coins[i][j] <= 1000  

	# Explanation
	Here's a solution to the problem, incorporating dynamic programming and handling the neutralization of robbers.

*   **Dynamic Programming with State:** We use dynamic programming to explore all possible paths. The state `dp[i][j][k]` represents the maximum profit achievable at cell (i, j) after neutralizing k robbers (k can be 0, 1, or 2).

*   **Transitions:**  At each cell (i, j), we can arrive either from the top (i-1, j) or the left (i, j-1). We consider the two possibilities: either neutralize the robber at the current cell (if coins[i][j] < 0 and we have neutralizations left) or don't.

*   **Base Case and Result:** The base case is `dp[0][0][k]` which is `coins[0][0]` with the appropriate number of robbers neutralized.  The result is `dp[m-1][n-1][k]` with max value of k being 0,1, or 2.

*   **Runtime Complexity:** O(m * n), where m and n are the dimensions of the grid.
*   **Storage Complexity:** O(m * n)

	
	# Code
	```python
	def max_profit(coins):
    m = len(coins)
    n = len(coins[0])

    dp = [[[float('-inf')] * 3 for _ in range(n)] for _ in range(m)]

    # Initialize the starting cell
    robbers = 1 if coins[0][0] < 0 else 0
    dp[0][0][robbers] = coins[0][0] if coins[0][0] >= 0 else 0

    dp[0][0][0] = coins[0][0]

    for i in range(m):
        for j in range(n):
            for k in range(3):

                # Skip the starting cell (already initialized)
                if i == 0 and j == 0:
                    continue
                
                current_coins = coins[i][j]
                
                # Transition from the top
                if i > 0:
                    # Option 1: Don't neutralize the robber
                    if current_coins >= 0:
                        dp[i][j][k] = max(dp[i][j][k], dp[i-1][j][k] + current_coins)
                    else:
                        if k > 0:  # Neutralize the robber
                            dp[i][j][k] = max(dp[i][j][k], dp[i-1][j][k-1])
                        else:  # Encounter the robber
                            dp[i][j][k] = max(dp[i][j][k], dp[i-1][j][k] + current_coins) #coins is already negative
                
                # Transition from the left
                if j > 0:
                    # Option 1: Don't neutralize the robber
                    if current_coins >= 0:
                        dp[i][j][k] = max(dp[i][j][k], dp[i][j-1][k] + current_coins)
                    else:
                        if k > 0:  # Neutralize the robber
                            dp[i][j][k] = max(dp[i][j][k], dp[i][j-1][k-1])
                        else:  # Encounter the robber
                            dp[i][j][k] = max(dp[i][j][k], dp[i][j-1][k] + current_coins) #coins is already negative

    return max(dp[m-1][n-1])
	```