chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Hard/2025-12-31-1970-Last-Day-Where-You-Can-Still-Cross/explanation.md

@@ -0,0 +1,42 @@
+# Last Day Where You Can Still Cross (Hard)
+
+**Problem ID:** 1970  
+**Date:** 2025-12-31  
+**Link:** https://leetcode.com/problems/last-day-where-you-can-still-cross/
+
+## Approach
+
+To solve the problem of determining the last day where it is possible to walk from the top to the bottom of a binary matrix as cells become flooded, we can utilize a binary search approach combined with a flood-fill algorithm (such as BFS or DFS). Here's a concise explanation of the approach:
+
+### Main Idea
+The key idea is to use binary search to efficiently find the last day where a path exists from the top row to the bottom row of the matrix. For each day in the binary search, we simulate the flooding of cells and check if a path can still be traversed.
+
+### Steps
+1. **Binary Search Setup**: 
+   - Initialize two pointers: `left` at 0 (the first day) and `right` at `len(cells) - 1` (the last day).
+   - The goal is to find the maximum day where crossing is still possible.
+
+2. **Flooding Simulation**:
+   - For a mid-point day in the binary search, create a matrix representation of the flooded state based on the `cells` array up to that day.
+   - Mark the cells that have been flooded (set them to 1).
+
+3. **Pathfinding**:
+   - Use a flood-fill algorithm (BFS or DFS) to check if there exists a path from any cell in the top row (first row) to any cell in the bottom row (last row) using only the land cells (0s).
+   - Start the search from all land cells in the top row and explore downwards, marking visited cells to avoid cycles.
+
+4. **Adjusting Binary Search**:
+   - If a path exists for the current mid-day, it means we can potentially find a later day, so move the `left` pointer to `mid + 1`.
+   - If no path exists, it means we need to check earlier days, so move the `right` pointer to `mid - 1`.
+
+5. **Result**:
+   - The last valid day where a path exists will be stored in `right` after the binary search concludes.
+
+### Data Structures
+- **Matrix**: A 2D array to represent the flooded state of the grid.
+- **Queue/Stack**: For BFS or DFS to explore the matrix and find paths.
+
+### Complexity
+- **Time Complexity**: O((row * col) * log(days)), where `days` is the number of days (length of `cells`). Each day requires a flood-fill operation which takes O(row * col) time.
+- **Space Complexity**: O(row * col) for the matrix and additional space for the queue/stack used in the flood-fill.
+
+This approach efficiently narrows down the search space while ensuring that we accurately check the connectivity of land cells in the matrix as it changes over the days.

Hard/2025-12-31-1970-Last-Day-Where-You-Can-Still-Cross/solution.java

@@ -0,0 +1,53 @@
+class Solution {
+    public int latestDayToCross(int row, int col, int[][] cells) {
+        int left = 0, right = cells.length - 1;
+        while (left < right) {
+            int mid = left + (right - left + 1) / 2;
+            if (canCross(row, col, cells, mid)) {
+                left = mid;
+            } else {
+                right = mid - 1;
+            }
+        }
+        return left;
+    }
+
+    private boolean canCross(int row, int col, int[][] cells, int day) {
+        boolean[][] grid = new boolean[row][col];
+        for (int i = 0; i < day; i++) {
+            int r = cells[i][0] - 1;
+            int c = cells[i][1] - 1;
+            grid[r][c] = true;
+        }
+        
+        boolean[] visited = new boolean[col];
+        for (int j = 0; j < col; j++) {
+            if (!grid[0][j]) {
+                visited[j] = true;
+            }
+        }
+
+        for (int i = 0; i < row; i++) {
+            boolean[] newVisited = new boolean[col];
+            for (int j = 0; j < col; j++) {
+                if (visited[j] && !grid[i][j]) {
+                    newVisited[j] = true;
+                    if (i == row - 1) {
+                        return true;
+                    }
+                    if (j > 0 && !grid[i][j - 1]) {
+                        newVisited[j - 1] = true;
+                    }
+                    if (j < col - 1 && !grid[i][j + 1]) {
+                        newVisited[j + 1] = true;
+                    }
+                    if (i < row - 1 && !grid[i + 1][j]) {
+                        newVisited[j] = true;
+                    }
+                }
+            }
+            visited = newVisited;
+        }
+        return false;
+    }
+}

Hard/2025-12-31-1970-Last-Day-Where-You-Can-Still-Cross/solution.js

@@ -0,0 +1,47 @@
+var latestDayToCross = function(row, col, cells) {
+    const isValid = (grid) => {
+        const visited = Array.from({ length: row }, () => Array(col).fill(false));
+        const queue = [];
+        
+        for (let c = 0; c < col; c++) {
+            if (grid[0][c] === 0) {
+                queue.push([0, c]);
+                visited[0][c] = true;
+            }
+        }
+        
+        while (queue.length) {
+            const [r, c] = queue.shift();
+            if (r === row - 1) return true;
+            for (const [dr, dc] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {
+                const nr = r + dr, nc = c + dc;
+                if (nr >= 0 && nr < row && nc >= 0 && nc < col && !visited[nr][nc] && grid[nr][nc] === 0) {
+                    visited[nr][nc] = true;
+                    queue.push([nr, nc]);
+                }
+            }
+        }
+        return false;
+    };
+
+    let left = 0, right = cells.length - 1, answer = 0;
+    
+    while (left <= right) {
+        const mid = Math.floor((left + right) / 2);
+        const grid = Array.from({ length: row }, () => Array(col).fill(0));
+        
+        for (let i = 0; i <= mid; i++) {
+            const [r, c] = cells[i];
+            grid[r - 1][c - 1] = 1;
+        }
+        
+        if (isValid(grid)) {
+            answer = mid + 1;
+            left = mid + 1;
+        } else {
+            right = mid - 1;
+        }
+    }
+    
+    return answer;
+};

Hard/2025-12-31-1970-Last-Day-Where-You-Can-Still-Cross/solution.py

@@ -0,0 +1,43 @@
+class Solution:
+    def canCross(self, row, col, cells, day):
+        grid = [[0] * col for _ in range(row)]
+        for i in range(day):
+            r, c = cells[i]
+            grid[r - 1][c - 1] = 1
+        
+        visited = [[False] * col for _ in range(row)]
+        queue = collections.deque()
+        
+        for c in range(col):
+            if grid[0][c] == 0:
+                queue.append((0, c))
+                visited[0][c] = True
+        
+        directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]
+        
+        while queue:
+            r, c = queue.popleft()
+            if r == row - 1:
+                return True
+            
+            for dr, dc in directions:
+                nr, nc = r + dr, c + dc
+                if 0 <= nr < row and 0 <= nc < col and not visited[nr][nc] and grid[nr][nc] == 0:
+                    visited[nr][nc] = True
+                    queue.append((nr, nc))
+        
+        return False
+
+    def latestDayToCross(self, row: int, col: int, cells: List[List[int]]) -> int:
+        left, right = 1, len(cells)
+        answer = 0
+        
+        while left <= right:
+            mid = (left + right) // 2
+            if self.canCross(row, col, cells, mid):
+                answer = mid
+                left = mid + 1
+            else:
+                right = mid - 1
+        
+        return answer

README.md

@@ -321,3 +321,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2025-12-28 — [Count Negative Numbers in a Sorted Matrix](https://leetcode.com/problems/count-negative-numbers-in-a-sorted-matrix/) (Easy) → `Easy/2025-12-28-1351-Count-Negative-Numbers-in-a-Sorted-Matrix`
 - 2025-12-29 — [Pyramid Transition Matrix](https://leetcode.com/problems/pyramid-transition-matrix/) (Medium) → `Medium/2025-12-29-756-Pyramid-Transition-Matrix`
 - 2025-12-30 — [Magic Squares In Grid](https://leetcode.com/problems/magic-squares-in-grid/) (Medium) → `Medium/2025-12-30-840-Magic-Squares-In-Grid`
+- 2025-12-31 — [Last Day Where You Can Still Cross](https://leetcode.com/problems/last-day-where-you-can-still-cross/) (Hard) → `Hard/2025-12-31-1970-Last-Day-Where-You-Can-Still-Cross`