chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Hard/2025-10-06-778-Swim-in-Rising-Water/explanation.md

@@ -0,0 +1,32 @@
+# Swim in Rising Water (Hard)
+
+**Problem ID:** 778  
+**Date:** 2025-10-06  
+**Link:** https://leetcode.com/problems/swim-in-rising-water/
+
+## Approach
+
+To solve the "Swim in Rising Water" problem, we can utilize a combination of a priority queue (min-heap) and a breadth-first search (BFS) strategy to efficiently determine the minimum time required to reach the bottom-right corner of the grid from the top-left corner.
+
+### Main Idea:
+The key insight is that the problem can be viewed as a pathfinding problem where the cost of moving through a cell is determined by the water level (time `t`). The goal is to find the minimum `t` such that there exists a path from the starting cell `(0, 0)` to the target cell `(n-1, n-1)` where all cells in the path have elevations less than or equal to `t`.
+
+### Approach:
+1. **Min-Heap for Priority Queue**: Use a min-heap to explore cells in the order of their elevation values. This allows us to always consider the lowest elevation cell that is reachable at the current water level.
+  
+2. **BFS with Priority Queue**: Start from the top-left cell `(0, 0)` and push it into the min-heap. While the heap is not empty:
+   - Extract the cell with the minimum elevation (this represents the current water level we can swim at).
+   - Check if this cell is the bottom-right cell. If it is, the elevation at this cell is the minimum time required to reach it.
+   - Otherwise, explore the 4-directionally adjacent cells (up, down, left, right). For each adjacent cell, if it is within bounds and has not been visited, push it into the heap with its elevation.
+
+3. **Visited Set**: Maintain a set to keep track of visited cells to prevent reprocessing and infinite loops.
+
+### Data Structures:
+- **Min-Heap (Priority Queue)**: To efficiently get the cell with the minimum elevation.
+- **Set/Array for Visited Cells**: To track which cells have already been processed.
+
+### Complexity:
+- **Time Complexity**: O(n^2 log(n)), where n is the dimension of the grid. Each cell is pushed and popped from the heap once, and heap operations take logarithmic time.
+- **Space Complexity**: O(n^2) for the visited set and the heap, which can store all cells in the worst case.
+
+This approach ensures that we find the minimum time required to swim to the target cell while efficiently managing the elevation constraints imposed by the grid.

Hard/2025-10-06-778-Swim-in-Rising-Water/solution.java

@@ -0,0 +1,34 @@
+import java.util.PriorityQueue;
+
+class Solution {
+    public int swimInWater(int[][] grid) {
+        int n = grid.length;
+        int[][] directions = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+        boolean[][] visited = new boolean[n][n];
+        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> Integer.compare(a[0], b[0]));
+        pq.offer(new int[]{grid[0][0], 0, 0});
+        visited[0][0] = true;
+
+        while (!pq.isEmpty()) {
+            int[] current = pq.poll();
+            int time = current[0];
+            int x = current[1];
+            int y = current[2];
+
+            if (x == n - 1 && y == n - 1) {
+                return time;
+            }
+
+            for (int[] dir : directions) {
+                int newX = x + dir[0];
+                int newY = y + dir[1];
+
+                if (newX >= 0 && newX < n && newY >= 0 && newY < n && !visited[newX][newY]) {
+                    visited[newX][newY] = true;
+                    pq.offer(new int[]{Math.max(time, grid[newX][newY]), newX, newY});
+                }
+            }
+        }
+        return -1; // This line should never be reached
+    }
+}

Hard/2025-10-06-778-Swim-in-Rising-Water/solution.js

@@ -0,0 +1,36 @@
+var swimInWater = function(grid) {
+    const n = grid.length;
+    const directions = [[0, 1], [1, 0], [0, -1], [-1, 0]];
+    let left = 0, right = Math.max(...grid.flat());
+
+    const canSwim = (t) => {
+        const visited = Array.from({ length: n }, () => Array(n).fill(false));
+        const queue = [[0, 0]];
+        visited[0][0] = true;
+
+        while (queue.length) {
+            const [x, y] = queue.shift();
+            if (x === n - 1 && y === n - 1) return true;
+
+            for (const [dx, dy] of directions) {
+                const nx = x + dx, ny = y + dy;
+                if (nx >= 0 && nx < n && ny >= 0 && ny < n && !visited[nx][ny] && grid[nx][ny] <= t) {
+                    visited[nx][ny] = true;
+                    queue.push([nx, ny]);
+                }
+            }
+        }
+        return false;
+    };
+
+    while (left < right) {
+        const mid = Math.floor((left + right) / 2);
+        if (canSwim(mid)) {
+            right = mid;
+        } else {
+            left = mid + 1;
+        }
+    }
+
+    return left;
+};

Hard/2025-10-06-778-Swim-in-Rising-Water/solution.py

@@ -0,0 +1,19 @@
+import heapq
+
+class Solution:
+    def swimInWater(self, grid: List[List[int]]) -> int:
+        n = len(grid)
+        directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
+        min_heap = [(grid[0][0], 0, 0)]
+        visited = set((0, 0))
+        
+        while min_heap:
+            t, x, y = heapq.heappop(min_heap)
+            if (x, y) == (n - 1, n - 1):
+                return t
+            
+            for dx, dy in directions:
+                nx, ny = x + dx, y + dy
+                if 0 <= nx < n and 0 <= ny < n and (nx, ny) not in visited:
+                    visited.add((nx, ny))
+                    heapq.heappush(min_heap, (max(t, grid[nx][ny]), nx, ny))

README.md

@@ -168,3 +168,4 @@ Each problem includes:
 - 2025-10-03 — [Trapping Rain Water II](https://leetcode.com/problems/trapping-rain-water-ii/) (Hard) → `Hard/2025-10-03-407-Trapping-Rain-Water-II`
 - 2025-10-04 — [Container With Most Water](https://leetcode.com/problems/container-with-most-water/) (Medium) → `Medium/2025-10-04-11-Container-With-Most-Water`
 - 2025-10-05 — [Pacific Atlantic Water Flow](https://leetcode.com/problems/pacific-atlantic-water-flow/) (Medium) → `Medium/2025-10-05-417-Pacific-Atlantic-Water-Flow`
+- 2025-10-06 — [Swim in Rising Water](https://leetcode.com/problems/swim-in-rising-water/) (Hard) → `Hard/2025-10-06-778-Swim-in-Rising-Water`