chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2025-10-07-1488-Avoid-Flood-in-The-City/explanation.md

@@ -0,0 +1,39 @@
+# Avoid Flood in The City (Medium)
+
+**Problem ID:** 1488  
+**Date:** 2025-10-07  
+**Link:** https://leetcode.com/problems/avoid-flood-in-the-city/
+
+## Approach
+
+To solve the "Avoid Flood in The City" problem, we can use a greedy approach combined with a hash set to keep track of the lakes that are currently full. The main idea is to process each day's rain and manage the drying of lakes effectively to avoid floods.
+
+### Approach:
+
+1. **Initialization**:
+   - Create an array `ans` of the same length as `rains`, initialized with `-1` to indicate days when it rains.
+   - Use a hash set `fullLakes` to track which lakes are currently full.
+   - Use a list `dryDays` to record the indices of days when no rain occurs (i.e., `rains[i] == 0`).
+
+2. **Processing Rain Days**:
+   - Iterate through the `rains` array:
+     - If `rains[i] > 0` (it rains on lake `rains[i]`):
+       - Check if the lake is already in `fullLakes`. If it is, it means a flood will occur, and we should return an empty array.
+       - Otherwise, add the lake to `fullLakes` and set `ans[i]` to `-1` (indicating rain on this day).
+     - If `rains[i] == 0` (no rain):
+       - If there are full lakes (i.e., `fullLakes` is not empty), we can choose one lake to dry. We can pick any lake from `fullLakes`, remove it from `fullLakes`, and record the dried lake in `ans[i]`.
+       - If there are no full lakes, we can choose not to dry any lake, and `ans[i]` remains `-1`.
+
+3. **Final Output**:
+   - After processing all days, the `ans` array will contain the required output. If we encountered a situation where a flood was unavoidable, we would have returned an empty array earlier.
+
+### Data Structures:
+- **Array**: To store the results for each day.
+- **Hash Set**: To track full lakes efficiently, allowing O(1) average time complexity for insertions and lookups.
+- **List**: To keep track of dry days, although it is not strictly necessary for the solution.
+
+### Complexity:
+- **Time Complexity**: O(n), where n is the length of the `rains` array. We make a single pass through the array and perform constant-time operations for each element.
+- **Space Complexity**: O(m), where m is the number of unique lakes that have been filled. In the worst case, this can be up to O(n) if all lakes are unique.
+
+This approach efficiently manages the constraints of the problem while ensuring that floods are avoided wherever possible.

Medium/2025-10-07-1488-Avoid-Flood-in-The-City/solution.java

@@ -0,0 +1,38 @@
+import java.util.*;
+
+class Solution {
+    public int[] avoidFlood(int[] rains) {
+        int n = rains.length;
+        int[] ans = new int[n];
+        Arrays.fill(ans, -1);
+        
+        Set<Integer> fullLakes = new HashSet<>();
+        Queue<Integer> dryDays = new PriorityQueue<>();
+        
+        for (int i = 0; i < n; i++) {
+            if (rains[i] > 0) {
+                int lake = rains[i];
+                if (fullLakes.contains(lake)) {
+                    return new int[0]; // Flood occurs
+                }
+                fullLakes.add(lake);
+                ans[i] = -1; // It rained, no drying
+                dryDays.offer(i); // Store the day we can dry this lake
+            } else {
+                ans[i] = 1; // Default to drying lake 1
+            }
+            
+            // Dry lakes on days where it rained before
+            while (!dryDays.isEmpty() && !fullLakes.isEmpty()) {
+                int dryDay = dryDays.poll();
+                if (ans[dryDay] == 1) {
+                    int lakeToDry = fullLakes.iterator().next();
+                    fullLakes.remove(lakeToDry);
+                    ans[dryDay] = lakeToDry; // Dry this lake
+                }
+            }
+        }
+        
+        return ans;
+    }
+}

Medium/2025-10-07-1488-Avoid-Flood-in-The-City/solution.js

@@ -0,0 +1,35 @@
+var avoidFlood = function(rains) {
+    const n = rains.length;
+    const ans = new Array(n).fill(-1);
+    const fullLakes = new Set();
+    const dryDays = [];
+    
+    for (let i = 0; i < n; i++) {
+        if (rains[i] > 0) {
+            if (fullLakes.has(rains[i])) {
+                return [];
+            }
+            fullLakes.add(rains[i]);
+        } else {
+            dryDays.push(i);
+        }
+    }
+    
+    for (let i = 0; i < n; i++) {
+        if (rains[i] > 0) {
+            ans[i] = -1;
+            const lake = rains[i];
+            fullLakes.delete(lake);
+        } else {
+            if (fullLakes.size > 0) {
+                const lakeToDry = fullLakes.values().next().value;
+                ans[i] = lakeToDry;
+                fullLakes.delete(lakeToDry);
+            } else if (dryDays.length > 0) {
+                ans[i] = 1; // Dry any lake (1 is arbitrary)
+            }
+        }
+    }
+    
+    return ans;
+};

Medium/2025-10-07-1488-Avoid-Flood-in-The-City/solution.py

@@ -0,0 +1,25 @@
+class Solution:
+    def avoidFlood(self, rains: List[int]) -> List[int]:
+        from collections import defaultdict
+        
+        full_lakes = set()
+        ans = [-1] * len(rains)
+        dry_days = []
+        
+        for i, lake in enumerate(rains):
+            if lake > 0:
+                if lake in full_lakes:
+                    return []
+                full_lakes.add(lake)
+                ans[i] = -1
+            else:
+                dry_days.append(i)
+                ans[i] = 0
+        
+        for lake in full_lakes:
+            if not dry_days:
+                return []
+            dry_day = dry_days.pop(0)
+            ans[dry_day] = lake
+        
+        return ans

README.md

@@ -169,3 +169,4 @@ Each problem includes:
 - 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`
+- 2025-10-07 — [Avoid Flood in The City](https://leetcode.com/problems/avoid-flood-in-the-city/) (Medium) → `Medium/2025-10-07-1488-Avoid-Flood-in-The-City`