chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2026-04-30-3742-Maximum-Path-Score-in-a-Grid/explanation.md

@@ -0,0 +1,37 @@
+# Maximum Path Score in a Grid (Medium)
+
+**Problem ID:** 3742  
+**Date:** 2026-04-30  
+**Link:** https://leetcode.com/problems/maximum-path-score-in-a-grid/
+
+## Approach
+
+To solve the "Maximum Path Score in a Grid" problem, we can utilize a dynamic programming approach combined with a breadth-first search (BFS) strategy. The main idea is to explore all possible paths from the top-left corner to the bottom-right corner of the grid while keeping track of the accumulated score and cost.
+
+### Approach:
+
+1. **Data Structures**:
+   - Use a 2D list `dp` where `dp[i][j]` represents the maximum score achievable when reaching cell `(i, j)` with a cost not exceeding `k`.
+   - A queue (for BFS) to explore the cells in the grid, initialized with the starting cell `(0, 0)`.
+
+2. **Initialization**:
+   - Start by setting `dp[0][0]` to 0, as starting at the top-left corner incurs no cost and adds no score.
+   - For all other cells, initialize `dp[i][j]` to -1 (indicating unreachable).
+
+3. **BFS Exploration**:
+   - While there are cells in the queue, pop the front cell `(i, j)` and explore its neighbors (right `(i, j+1)` and down `(i+1, j)`).
+   - For each neighbor, calculate the new score and cost based on the value in the grid:
+     - If the grid value is `0`, it adds `0` to the score and incurs `0` cost.
+     - If the grid value is `1`, it adds `1` to the score and incurs `1` cost.
+     - If the grid value is `2`, it adds `2` to the score and incurs `1` cost.
+   - Check if the new cost exceeds `k`. If it does, skip that neighbor.
+   - If the new score is greater than the current maximum score recorded in `dp` for that neighbor, update `dp` and add the neighbor to the queue for further exploration.
+
+4. **Final Check**:
+   - After exploring all possible paths, check the value in `dp[m-1][n-1]`. If it remains `-1`, return `-1` indicating no valid path exists. Otherwise, return the maximum score found.
+
+### Complexity:
+- **Time Complexity**: O(m * n), where m is the number of rows and n is the number of columns in the grid. Each cell is processed at most once.
+- **Space Complexity**: O(m * n) for the `dp` array and O(m * n) for the queue in the worst case.
+
+This approach ensures that we efficiently explore all valid paths while adhering to the constraints of the problem, ultimately leading to the maximum score achievable without exceeding the specified cost.

Medium/2026-04-30-3742-Maximum-Path-Score-in-a-Grid/solution.java

@@ -0,0 +1,41 @@
+import java.util.*;
+
+class Solution {
+    public int maxPathScore(int[][] grid, int k) {
+        int m = grid.length, n = grid[0].length;
+        int[][][] dp = new int[m][n][k + 1];
+        for (int[][] arr : dp) {
+            for (int[] a : arr) {
+                Arrays.fill(a, -1);
+            }
+        }
+        dp[0][0][0] = 0;
+
+        for (int cost = 0; cost <= k; cost++) {
+            for (int i = 0; i < m; i++) {
+                for (int j = 0; j < n; j++) {
+                    if (dp[i][j][cost] == -1) continue;
+                    int score = dp[i][j][cost];
+                    if (i + 1 < m) {
+                        int newCost = cost + (grid[i + 1][j] == 1 ? 1 : (grid[i + 1][j] == 2 ? 1 : 0));
+                        if (newCost <= k) {
+                            dp[i + 1][j][newCost] = Math.max(dp[i + 1][j][newCost], score + grid[i + 1][j]);
+                        }
+                    }
+                    if (j + 1 < n) {
+                        int newCost = cost + (grid[i][j + 1] == 1 ? 1 : (grid[i][j + 1] == 2 ? 1 : 0));
+                        if (newCost <= k) {
+                            dp[i][j + 1][newCost] = Math.max(dp[i][j + 1][newCost], score + grid[i][j + 1]);
+                        }
+                    }
+                }
+            }
+        }
+
+        int maxScore = -1;
+        for (int cost = 0; cost <= k; cost++) {
+            maxScore = Math.max(maxScore, dp[m - 1][n - 1][cost]);
+        }
+        return maxScore;
+    }
+}

Medium/2026-04-30-3742-Maximum-Path-Score-in-a-Grid/solution.js

@@ -0,0 +1,42 @@
+class Solution {
+    maxScore(grid, k) {
+        const m = grid.length;
+        const n = grid[0].length;
+        const dp = Array.from({ length: m }, () => Array.from({ length: n }, () => Array(k + 1).fill(-1)));
+        dp[0][0][0] = 0;
+
+        for (let i = 0; i < m; i++) {
+            for (let j = 0; j < n; j++) {
+                for (let cost = 0; cost <= k; cost++) {
+                    if (dp[i][j][cost] === -1) continue;
+                    const score = dp[i][j][cost];
+
+                    // Move right
+                    if (j + 1 < n) {
+                        const nextCost = cost + (grid[i][j + 1] === 1 ? 1 : grid[i][j + 1] === 2 ? 1 : 0);
+                        const nextScore = score + (grid[i][j + 1] === 1 ? 1 : grid[i][j + 1] === 2 ? 2 : 0);
+                        if (nextCost <= k) {
+                            dp[i][j + 1][nextCost] = Math.max(dp[i][j + 1][nextCost], nextScore);
+                        }
+                    }
+
+                    // Move down
+                    if (i + 1 < m) {
+                        const nextCost = cost + (grid[i + 1][j] === 1 ? 1 : grid[i + 1][j] === 2 ? 1 : 0);
+                        const nextScore = score + (grid[i + 1][j] === 1 ? 1 : grid[i + 1][j] === 2 ? 2 : 0);
+                        if (nextCost <= k) {
+                            dp[i + 1][j][nextCost] = Math.max(dp[i + 1][j][nextCost], nextScore);
+                        }
+                    }
+                }
+            }
+        }
+
+        let maxScore = -1;
+        for (let cost = 0; cost <= k; cost++) {
+            maxScore = Math.max(maxScore, dp[m - 1][n - 1][cost]);
+        }
+
+        return maxScore;
+    }
+}

Medium/2026-04-30-3742-Maximum-Path-Score-in-a-Grid/solution.py

@@ -0,0 +1,27 @@
+from collections import deque
+
+class Solution:
+    def maxPathScore(self, grid: List[List[int]], k: int) -> int:
+        m, n = len(grid), len(grid[0])
+        directions = [(1, 0), (0, 1)]
+        dp = [[-1] * (k + 1) for _ in range(m)]
+        dp[0][0] = 0
+        
+        for cost in range(k + 1):
+            for i in range(m):
+                for j in range(n):
+                    if dp[i][cost] != -1:
+                        for di, dj in directions:
+                            ni, nj = i + di, j + dj
+                            if ni < m and nj < n:
+                                new_cost = cost
+                                if grid[ni][nj] == 1:
+                                    new_cost += 1
+                                elif grid[ni][nj] == 2:
+                                    new_cost += 1
+                                if new_cost <= k:
+                                    new_score = dp[i][cost] + grid[ni][nj]
+                                    dp[ni][new_cost] = max(dp[ni][new_cost], new_score)
+        
+        max_score = max(dp[m - 1])
+        return max_score if max_score != -1 else -1

README.md

@@ -439,3 +439,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-04-27 — [Check if There is a Valid Path in a Grid](https://leetcode.com/problems/check-if-there-is-a-valid-path-in-a-grid/) (Medium) → `Medium/2026-04-27-1391-Check-if-There-is-a-Valid-Path-in-a-Grid`
 - 2026-04-28 — [Minimum Operations to Make a Uni-Value Grid](https://leetcode.com/problems/minimum-operations-to-make-a-uni-value-grid/) (Medium) → `Medium/2026-04-28-2033-Minimum-Operations-to-Make-a-Uni-Value-Grid`
 - 2026-04-29 — [Maximum Score From Grid Operations](https://leetcode.com/problems/maximum-score-from-grid-operations/) (Hard) → `Hard/2026-04-29-3225-Maximum-Score-From-Grid-Operations`
+- 2026-04-30 — [Maximum Path Score in a Grid](https://leetcode.com/problems/maximum-path-score-in-a-grid/) (Medium) → `Medium/2026-04-30-3742-Maximum-Path-Score-in-a-Grid`