chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2026-04-27-1391-Check-if-There-is-a-Valid-Path-in-a-Grid/explanation.md

@@ -0,0 +1,37 @@
+# Check if There is a Valid Path in a Grid (Medium)
+
+**Problem ID:** 1391  
+**Date:** 2026-04-27  
+**Link:** https://leetcode.com/problems/check-if-there-is-a-valid-path-in-a-grid/
+
+## Approach
+
+To solve the problem of checking if there is a valid path in the grid, we can utilize a graph traversal approach, specifically Depth-First Search (DFS) or Breadth-First Search (BFS). The main idea is to explore the grid starting from the upper-left cell (0, 0) and determine if we can reach the bottom-right cell (m - 1, n - 1) by following the connections defined by the street types in each cell.
+
+### Approach:
+
+1. **Understanding Connections**: Each cell in the grid has a specific type (from 1 to 6), which defines how it connects to its neighboring cells:
+   - Type 1 connects left and right.
+   - Type 2 connects up and down.
+   - Type 3 connects left and down.
+   - Type 4 connects right and down.
+   - Type 5 connects left and up.
+   - Type 6 connects right and up.
+   
+   We need to define the valid movements based on these types. For example, if we are at cell (i, j) with type 1, we can move to (i, j-1) or (i, j+1) if those indices are valid.
+
+2. **Traversal Strategy**: We can use either DFS or BFS to explore the grid. We maintain a set or a boolean matrix to keep track of visited cells to avoid cycles and unnecessary revisits.
+
+3. **Starting Point**: Begin the traversal from the cell (0, 0). Check the possible movements based on the street type and move to the adjacent cells if they are valid and not visited.
+
+4. **Termination Condition**: The traversal continues until we either reach the target cell (m - 1, n - 1) or exhaust all possible paths. If we reach the target cell, we return `true`. If we finish exploring without reaching the target, we return `false`.
+
+### Data Structures:
+- A stack (for DFS) or a queue (for BFS) to manage the cells to be explored.
+- A set or a 2D boolean array to track visited cells.
+
+### Complexity:
+- **Time Complexity**: O(m * n), where m is the number of rows and n is the number of columns in the grid. In the worst case, we may visit every cell once.
+- **Space Complexity**: O(m * n) for the visited structure and the stack/queue used for traversal.
+
+This approach efficiently checks for a valid path by leveraging the connections defined by the street types, ensuring that all potential routes are explored systematically.

Medium/2026-04-27-1391-Check-if-There-is-a-Valid-Path-in-a-Grid/solution.java

@@ -0,0 +1,57 @@
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class Solution {
+    public boolean hasValidPath(int[][] grid) {
+        int m = grid.length, n = grid[0].length;
+        boolean[][] visited = new boolean[m][n];
+        Queue<int[]> queue = new LinkedList<>();
+        queue.offer(new int[]{0, 0});
+        visited[0][0] = true;
+
+        while (!queue.isEmpty()) {
+            int[] cell = queue.poll();
+            int x = cell[0], y = cell[1];
+
+            if (x == m - 1 && y == n - 1) {
+                return true;
+            }
+
+            for (int[] direction : getDirections(grid[x][y])) {
+                int newX = x + direction[0], newY = y + direction[1];
+                if (isValid(newX, newY, m, n, visited, grid)) {
+                    visited[newX][newY] = true;
+                    queue.offer(new int[]{newX, newY});
+                }
+            }
+        }
+        return false;
+    }
+
+    private boolean isValid(int x, int y, int m, int n, boolean[][] visited, int[][] grid) {
+        return x >= 0 && x < m && y >= 0 && y < n && !visited[x][y] && canConnect(grid, x, y);
+    }
+
+    private boolean canConnect(int[][] grid, int x, int y) {
+        int cellType = grid[x][y];
+        if (cellType == 1) return true; // left-right
+        if (cellType == 2) return true; // up-down
+        if (cellType == 3) return x > 0 && grid[x - 1][y] == 2; // left-down
+        if (cellType == 4) return x < grid.length - 1 && grid[x + 1][y] == 2; // right-down
+        if (cellType == 5) return y > 0 && grid[x][y - 1] == 1; // left-up
+        if (cellType == 6) return y < grid[0].length - 1 && grid[x][y + 1] == 1; // right-up
+        return false;
+    }
+
+    private int[][] getDirections(int cellType) {
+        switch (cellType) {
+            case 1: return new int[][]{{0, 1}, {0, -1}}; // left-right
+            case 2: return new int[][]{{1, 0}, {-1, 0}}; // up-down
+            case 3: return new int[][]{{0, -1}, {1, 0}}; // left-down
+            case 4: return new int[][]{{0, 1}, {1, 0}}; // right-down
+            case 5: return new int[][]{{0, -1}, {-1, 0}}; // left-up
+            case 6: return new int[][]{{0, 1}, {-1, 0}}; // right-up
+            default: return new int[0][0];
+        }
+    }
+}

Medium/2026-04-27-1391-Check-if-There-is-a-Valid-Path-in-a-Grid/solution.js

@@ -0,0 +1,44 @@
+var hasValidPath = function(grid) {
+    const m = grid.length, n = grid[0].length;
+    const directions = {
+        1: [[0, 1], [0, -1]],
+        2: [[1, 0], [-1, 0]],
+        3: [[0, -1], [1, 0]],
+        4: [[0, 1], [1, 0]],
+        5: [[0, -1], [-1, 0]],
+        6: [[0, 1], [-1, 0]]
+    };
+    
+    const canConnect = {
+        1: [1, 1],
+        2: [1, 1],
+        3: [1, 0],
+        4: [0, 1],
+        5: [0, 1],
+        6: [1, 0]
+    };
+    
+    const visited = Array.from({ length: m }, () => Array(n).fill(false));
+    const queue = [[0, 0]];
+    visited[0][0] = true;
+
+    while (queue.length) {
+        const [x, y] = queue.shift();
+        if (x === m - 1 && y === n - 1) return true;
+
+        const currentStreet = grid[x][y];
+        for (const [dx, dy] of directions[currentStreet]) {
+            const nx = x + dx;
+            const ny = y + dy;
+            if (nx < 0 || ny < 0 || nx >= m || ny >= n || visited[nx][ny]) continue;
+
+            const nextStreet = grid[nx][ny];
+            if (canConnect[nextStreet][(dx === 0 ? 1 : 0)] && canConnect[nextStreet][(dy === 0 ? 1 : 0)]) {
+                visited[nx][ny] = true;
+                queue.push([nx, ny]);
+            }
+        }
+    }
+    
+    return false;
+};

Medium/2026-04-27-1391-Check-if-There-is-a-Valid-Path-in-a-Grid/solution.py

@@ -0,0 +1,38 @@
+class Solution:
+    def hasValidPath(self, grid: List[List[int]]) -> bool:
+        m, n = len(grid), len(grid[0])
+        directions = {
+            1: [(0, 1), (0, -1)],
+            2: [(1, 0), (-1, 0)],
+            3: [(0, 1), (1, 0)],
+            4: [(0, 1), (-1, 0)],
+            5: [(0, -1), (1, 0)],
+            6: [(0, -1), (-1, 0)]
+        }
+        connect = {
+            (0, 1): (0, -1),
+            (0, -1): (0, 1),
+            (1, 0): (-1, 0),
+            (-1, 0): (1, 0)
+        }
+        
+        def is_valid(x, y):
+            return 0 <= x < m and 0 <= y < n
+        
+        visited = set()
+        stack = [(0, 0)]
+        
+        while stack:
+            x, y = stack.pop()
+            if (x, y) in visited:
+                continue
+            visited.add((x, y))
+            if x == m - 1 and y == n - 1:
+                return True
+            
+            for dx, dy in directions[grid[x][y]]:
+                nx, ny = x + dx, y + dy
+                if is_valid(nx, ny) and (dx, dy) in connect and connect[(dx, dy)] in directions[grid[nx][ny]]:
+                    stack.append((nx, ny))
+        
+        return False

README.md

@@ -436,3 +436,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-04-24 — [Furthest Point From Origin](https://leetcode.com/problems/furthest-point-from-origin/) (Easy) → `Easy/2026-04-24-2833-Furthest-Point-From-Origin`
 - 2026-04-25 — [Maximize the Distance Between Points on a Square](https://leetcode.com/problems/maximize-the-distance-between-points-on-a-square/) (Hard) → `Hard/2026-04-25-3464-Maximize-the-Distance-Between-Points-on-a-Square`
 - 2026-04-26 — [Detect Cycles in 2D Grid](https://leetcode.com/problems/detect-cycles-in-2d-grid/) (Medium) → `Medium/2026-04-26-1559-Detect-Cycles-in-2D-Grid`
+- 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`