chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2026-04-02-3418-Maximum-Amount-of-Money-Robot-Can-Earn/explanation.md

@@ -0,0 +1,35 @@
+# Maximum Amount of Money Robot Can Earn (Medium)
+
+**Problem ID:** 3418  
+**Date:** 2026-04-02  
+**Link:** https://leetcode.com/problems/maximum-amount-of-money-robot-can-earn/
+
+## Approach
+
+To solve the problem of maximizing the amount of money the robot can earn while navigating through the grid, we can use a dynamic programming approach. 
+
+### Main Idea:
+The key is to maintain a dynamic programming table that tracks the maximum coins the robot can collect at each cell while considering the possibility of neutralizing up to 2 robbers. We will utilize a 3D DP array where `dp[i][j][k]` represents the maximum coins collected when reaching cell `(i, j)` with `k` neutralizations used (where `k` can be 0, 1, or 2).
+
+### Approach:
+1. **Initialization**: Start by initializing the DP table. The robot starts at `(0, 0)`, so set `dp[0][0][0]` to `coins[0][0]` if it's non-negative, or to `-inf` if it's negative (indicating an impossible state without neutralization).
+
+2. **Filling the DP Table**:
+   - Iterate through each cell `(i, j)` in the grid.
+   - For each cell, calculate the maximum coins collectible from the top `(i-1, j)` and left `(i, j-1)` cells for each neutralization state `k`.
+   - Depending on the value in `coins[i][j]`:
+     - If it's positive, simply add it to the maximum coins from the previous cells.
+     - If it's negative, check if neutralization is possible:
+       - If `k` is 0, the robot cannot neutralize, so the value is subtracted from the total.
+       - If `k` is 1 or 2, calculate the maximum coins by neutralizing the robbery (i.e., treat the negative value as 0 for that cell).
+
+3. **Final Result**: The result will be the maximum value found in the last cell `(m-1, n-1)` across all neutralization states (0, 1, and 2).
+
+### Data Structures:
+- A 3D array `dp[m][n][3]` to keep track of the maximum coins collected at each cell with different states of neutralization.
+
+### Complexity:
+- **Time Complexity**: O(m * n), as we iterate through each cell and perform constant-time operations for each of the three neutralization states.
+- **Space Complexity**: O(m * n), for storing the DP table.
+
+By following this structured approach, we ensure that we explore all potential paths the robot can take while maximizing the coins collected, effectively handling the constraints of robbers and neutralizations.

Medium/2026-04-02-3418-Maximum-Amount-of-Money-Robot-Can-Earn/solution.java

@@ -0,0 +1,53 @@
+class Solution {
+    public int maxCoins(int[][] coins) {
+        int m = coins.length, n = coins[0].length;
+        int[][][] dp = new int[m][n][3];
+        
+        for (int[][] layer : dp) {
+            for (int[] row : layer) {
+                Arrays.fill(row, Integer.MIN_VALUE);
+            }
+        }
+        
+        dp[0][0][0] = coins[0][0] >= 0 ? coins[0][0] : 0;
+        dp[0][0][1] = coins[0][0] < 0 ? -coins[0][0] : 0;
+        dp[0][0][2] = 0;
+
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                for (int k = 0; k < 3; k++) {
+                    if (dp[i][j][k] == Integer.MIN_VALUE) continue;
+
+                    int currentCoins = dp[i][j][k];
+                    if (i + 1 < m) {
+                        int nextCoins = currentCoins + coins[i + 1][j];
+                        if (coins[i + 1][j] < 0) {
+                            if (k < 2) {
+                                dp[i + 1][j][k + 1] = Math.max(dp[i + 1][j][k + 1], currentCoins);
+                            }
+                        } else {
+                            dp[i + 1][j][k] = Math.max(dp[i + 1][j][k], nextCoins);
+                        }
+                    }
+                    if (j + 1 < n) {
+                        int nextCoins = currentCoins + coins[i][j + 1];
+                        if (coins[i][j + 1] < 0) {
+                            if (k < 2) {
+                                dp[i][j + 1][k + 1] = Math.max(dp[i][j + 1][k + 1], currentCoins);
+                            }
+                        } else {
+                            dp[i][j + 1][k] = Math.max(dp[i][j + 1][k], nextCoins);
+                        }
+                    }
+                }
+            }
+        }
+
+        int maxProfit = Integer.MIN_VALUE;
+        for (int k = 0; k < 3; k++) {
+            maxProfit = Math.max(maxProfit, dp[m - 1][n - 1][k]);
+        }
+        
+        return maxProfit;
+    }
+}

Medium/2026-04-02-3418-Maximum-Amount-of-Money-Robot-Can-Earn/solution.js

@@ -0,0 +1,42 @@
+var maxCoins = function(coins) {
+    const m = coins.length;
+    const n = coins[0].length;
+    const dp = Array.from({ length: m }, () => Array.from({ length: n }, () => Array(3).fill(-Infinity)));
+    
+    dp[0][0][0] = coins[0][0] >= 0 ? coins[0][0] : 0;
+    if (coins[0][0] < 0) dp[0][0][1] = -coins[0][0];
+    if (coins[0][0] < 0) dp[0][0][2] = -coins[0][0];
+
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            for (let k = 0; k < 3; k++) {
+                if (i === 0 && j === 0) continue;
+
+                const currentCoins = coins[i][j];
+                const gain = currentCoins >= 0 ? currentCoins : 0;
+                const loss = currentCoins < 0 ? -currentCoins : 0;
+
+                if (i > 0) {
+                    dp[i][j][k] = Math.max(dp[i][j][k], dp[i - 1][j][k] + gain);
+                    if (k > 0) {
+                        dp[i][j][k] = Math.max(dp[i][j][k], dp[i - 1][j][k - 1] + gain);
+                    }
+                    if (k > 0 && loss > 0) {
+                        dp[i][j][k] = Math.max(dp[i][j][k], dp[i - 1][j][k - 1]);
+                    }
+                }
+                if (j > 0) {
+                    dp[i][j][k] = Math.max(dp[i][j][k], dp[i][j - 1][k] + gain);
+                    if (k > 0) {
+                        dp[i][j][k] = Math.max(dp[i][j][k], dp[i][j - 1][k - 1] + gain);
+                    }
+                    if (k > 0 && loss > 0) {
+                        dp[i][j][k] = Math.max(dp[i][j][k], dp[i][j - 1][k - 1]);
+                    }
+                }
+            }
+        }
+    }
+
+    return Math.max(dp[m - 1][n - 1][0], dp[m - 1][n - 1][1], dp[m - 1][n - 1][2]);
+};

Medium/2026-04-02-3418-Maximum-Amount-of-Money-Robot-Can-Earn/solution.py

@@ -0,0 +1,19 @@
+class Solution:
+    def maxCoins(self, coins: List[List[int]]) -> int:
+        m, n = len(coins), len(coins[0])
+        dp = [[[-float('inf')] * 3 for _ in range(n)] for _ in range(m)]
+        dp[0][0][0] = coins[0][0]
+        
+        for i in range(m):
+            for j in range(n):
+                for k in range(3):
+                    if i > 0:
+                        dp[i][j][k] = max(dp[i][j][k], dp[i-1][j][k] + coins[i][j])
+                        if coins[i][j] < 0 and k > 0:
+                            dp[i][j][k] = max(dp[i][j][k], dp[i-1][j][k-1] + coins[i][j])
+                    if j > 0:
+                        dp[i][j][k] = max(dp[i][j][k], dp[i][j-1][k] + coins[i][j])
+                        if coins[i][j] < 0 and k > 0:
+                            dp[i][j][k] = max(dp[i][j][k], dp[i][j-1][k-1] + coins[i][j])
+        
+        return max(dp[m-1][n-1])

README.md

@@ -411,3 +411,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-03-30 — [Check if Strings Can be Made Equal With Operations II](https://leetcode.com/problems/check-if-strings-can-be-made-equal-with-operations-ii/) (Medium) → `Medium/2026-03-30-2840-Check-if-Strings-Can-be-Made-Equal-With-Operations-II`
 - 2026-03-31 — [Lexicographically Smallest Generated String](https://leetcode.com/problems/lexicographically-smallest-generated-string/) (Hard) → `Hard/2026-03-31-3474-Lexicographically-Smallest-Generated-String`
 - 2026-04-01 — [Robot Collisions](https://leetcode.com/problems/robot-collisions/) (Hard) → `Hard/2026-04-01-2751-Robot-Collisions`
+- 2026-04-02 — [Maximum Amount of Money Robot Can Earn](https://leetcode.com/problems/maximum-amount-of-money-robot-can-earn/) (Medium) → `Medium/2026-04-02-3418-Maximum-Amount-of-Money-Robot-Can-Earn`