chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2025-10-05-417-Pacific-Atlantic-Water-Flow/explanation.md

@@ -0,0 +1,33 @@
+# Pacific Atlantic Water Flow (Medium)
+
+**Problem ID:** 417  
+**Date:** 2025-10-05  
+**Link:** https://leetcode.com/problems/pacific-atlantic-water-flow/
+
+## Approach
+
+To solve the "Pacific Atlantic Water Flow" problem, we can utilize a depth-first search (DFS) or breadth-first search (BFS) approach to explore the grid and determine which cells can flow to both oceans. The main idea is to perform two separate searches: one starting from the cells adjacent to the Pacific Ocean and another from the cells adjacent to the Atlantic Ocean. 
+
+### Approach:
+
+1. **Initialization**:
+   - Create two boolean matrices, `pacific_reachable` and `atlantic_reachable`, both of the same dimensions as the input matrix. These will keep track of which cells can reach the Pacific and Atlantic oceans, respectively.
+
+2. **DFS/BFS Traversal**:
+   - For each ocean, start from the border cells that are adjacent to that ocean. For the Pacific Ocean, this includes the top row and the left column; for the Atlantic Ocean, this includes the bottom row and the right column.
+   - Use a DFS or BFS to explore from these starting cells. During the traversal:
+     - Mark the current cell as reachable for the corresponding ocean.
+     - For each neighboring cell (up, down, left, right), check if it can be reached (i.e., its height is less than or equal to the current cell's height). If it can be reached and hasn't been visited yet, continue the search from that cell.
+
+3. **Collect Results**:
+   - After both searches are complete, iterate through the grid and collect the coordinates of cells that are marked as reachable in both `pacific_reachable` and `atlantic_reachable`.
+
+### Data Structures:
+- Two 2D boolean arrays for tracking reachability.
+- A stack or queue for implementing the DFS or BFS.
+
+### Complexity:
+- **Time Complexity**: O(m * n), where m is the number of rows and n is the number of columns. Each cell is visited at most twice (once for each ocean).
+- **Space Complexity**: O(m * n) for the two boolean matrices used to track reachability.
+
+This approach efficiently determines the cells from which water can flow to both oceans by leveraging the properties of DFS/BFS to explore the grid based on height constraints.

Medium/2025-10-05-417-Pacific-Atlantic-Water-Flow/solution.java

@@ -0,0 +1,51 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    public List<List<Integer>> pacificAtlantic(int[][] heights) {
+        if (heights == null || heights.length == 0 || heights[0].length == 0) {
+            return new ArrayList<>();
+        }
+        
+        int m = heights.length, n = heights[0].length;
+        boolean[][] pacific = new boolean[m][n];
+        boolean[][] atlantic = new boolean[m][n];
+        List<List<Integer>> result = new ArrayList<>();
+        
+        for (int i = 0; i < m; i++) {
+            dfs(heights, pacific, i, 0); // Pacific Ocean
+            dfs(heights, atlantic, i, n - 1); // Atlantic Ocean
+        }
+        
+        for (int j = 0; j < n; j++) {
+            dfs(heights, pacific, 0, j); // Pacific Ocean
+            dfs(heights, atlantic, m - 1, j); // Atlantic Ocean
+        }
+        
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                if (pacific[i][j] && atlantic[i][j]) {
+                    List<Integer> cell = new ArrayList<>();
+                    cell.add(i);
+                    cell.add(j);
+                    result.add(cell);
+                }
+            }
+        }
+        
+        return result;
+    }
+    
+    private void dfs(int[][] heights, boolean[][] ocean, int i, int j) {
+        ocean[i][j] = true;
+        int[][] directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
+        
+        for (int[] dir : directions) {
+            int ni = i + dir[0], nj = j + dir[1];
+            if (ni >= 0 && ni < heights.length && nj >= 0 && nj < heights[0].length 
+                && !ocean[ni][nj] && heights[ni][nj] >= heights[i][j]) {
+                dfs(heights, ocean, ni, nj);
+            }
+        }
+    }
+}

Medium/2025-10-05-417-Pacific-Atlantic-Water-Flow/solution.js

@@ -0,0 +1,37 @@
+var pacificAtlantic = function(heights) {
+    if (!heights.length || !heights[0].length) return [];
+
+    const m = heights.length, n = heights[0].length;
+    const pacific = Array.from({ length: m }, () => Array(n).fill(false));
+    const atlantic = Array.from({ length: m }, () => Array(n).fill(false));
+    const directions = [[0, 1], [1, 0], [0, -1], [-1, 0]];
+
+    const dfs = (r, c, visited, prevHeight) => {
+        if (r < 0 || r >= m || c < 0 || c >= n || visited[r][c] || heights[r][c] < prevHeight) {
+            return;
+        }
+        visited[r][c] = true;
+        for (const [dr, dc] of directions) {
+            dfs(r + dr, c + dc, visited, heights[r][c]);
+        }
+    };
+
+    for (let i = 0; i < m; i++) {
+        dfs(i, 0, pacific, heights[i][0]); // Pacific left edge
+        dfs(i, n - 1, atlantic, heights[i][n - 1]); // Atlantic right edge
+    }
+    for (let j = 0; j < n; j++) {
+        dfs(0, j, pacific, heights[0][j]); // Pacific top edge
+        dfs(m - 1, j, atlantic, heights[m - 1][j]); // Atlantic bottom edge
+    }
+
+    const result = [];
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            if (pacific[i][j] && atlantic[i][j]) {
+                result.push([i, j]);
+            }
+        }
+    }
+    return result;
+};

Medium/2025-10-05-417-Pacific-Atlantic-Water-Flow/solution.py

@@ -0,0 +1,31 @@
+class Solution:
+    def pacificAtlantic(self, heights: List[List[int]]) -> List[List[int]]:
+        if not heights:
+            return []
+        
+        m, n = len(heights), len(heights[0])
+        pacific_reachable = [[False] * n for _ in range(m)]
+        atlantic_reachable = [[False] * n for _ in range(m)]
+        
+        def dfs(r, c, reachable):
+            reachable[r][c] = True
+            for dr, dc in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
+                nr, nc = r + dr, c + dc
+                if 0 <= nr < m and 0 <= nc < n and not reachable[nr][nc] and heights[nr][nc] >= heights[r][c]:
+                    dfs(nr, nc, reachable)
+        
+        for i in range(m):
+            dfs(i, 0, pacific_reachable)
+            dfs(i, n - 1, atlantic_reachable)
+        
+        for j in range(n):
+            dfs(0, j, pacific_reachable)
+            dfs(m - 1, j, atlantic_reachable)
+        
+        result = []
+        for r in range(m):
+            for c in range(n):
+                if pacific_reachable[r][c] and atlantic_reachable[r][c]:
+                    result.append([r, c])
+        
+        return result

README.md

@@ -167,3 +167,4 @@ Each problem includes:
 - 2025-10-02 — [Water Bottles II](https://leetcode.com/problems/water-bottles-ii/) (Medium) → `Medium/2025-10-02-3100-Water-Bottles-II`
 - 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`