chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2026-01-13-3453-Separate-Squares-I/explanation.md

@@ -0,0 +1,39 @@
+# Separate Squares I (Medium)
+
+**Problem ID:** 3453  
+**Date:** 2026-01-13  
+**Link:** https://leetcode.com/problems/separate-squares-i/
+
+## Approach
+
+To solve the problem of finding the minimum y-coordinate value of a horizontal line that separates the total area of squares above and below it, we can follow a systematic approach:
+
+### Main Idea:
+The key idea is to utilize a binary search combined with a sweep line technique to efficiently compute the areas above and below a potential horizontal line at various y-coordinates. The goal is to find a y-coordinate where the areas are equal.
+
+### Approach:
+1. **Calculate Total Area**: First, calculate the total area of all squares. This will help in determining the target area for both above and below the line.
+
+2. **Binary Search Setup**: Since the y-coordinates can range significantly (up to \(10^9\)), we can use binary search to efficiently find the y-coordinate. Set the initial search bounds from 0 to the maximum y-coordinate of the squares plus their side lengths.
+
+3. **Area Calculation Function**: For a given y-coordinate (midpoint in binary search), compute the areas above and below the line:
+   - For each square, determine the portion of its area that lies above and below the line. This can be done by checking the square's y-coordinate and its height against the current midpoint.
+   - Accumulate the areas for all squares to get the total area above and below the line.
+
+4. **Adjust Binary Search**: Compare the areas:
+   - If the area above the line is greater than the area below, move the search to lower y-coordinates (i.e., adjust the upper bound).
+   - If the area below is greater, move to higher y-coordinates (i.e., adjust the lower bound).
+   - Continue this process until the search converges to a point where the areas are approximately equal (within the specified tolerance).
+
+5. **Precision Handling**: Since the problem requires the answer to be accurate within \(10^{-5}\), ensure that the binary search continues until the difference between the lower and upper bounds is less than this threshold.
+
+### Data Structures:
+- A simple list or array to store the squares and their properties (coordinates and side lengths).
+- Variables to track the total area and the areas above and below the line during calculations.
+
+### Complexity:
+- The binary search will run in \(O(\log(\text{max\_y}))\), where \(\text{max\_y}\) is the maximum y-coordinate considered.
+- For each midpoint in the binary search, calculating the areas involves iterating through all squares, which takes \(O(n)\), where \(n\) is the number of squares.
+- Therefore, the overall time complexity is \(O(n \log(\text{max\_y}))\).
+
+This approach efficiently narrows down the potential y-coordinate while ensuring that we accurately compute the areas, handling overlaps as specified in the problem statement.

Medium/2026-01-13-3453-Separate-Squares-I/solution.java

@@ -0,0 +1,53 @@
+import java.util.*;
+
+public class Solution {
+    public double findMedianHeight(int[][] squares) {
+        List<Double> heights = new ArrayList<>();
+        for (int[] square : squares) {
+            int x = square[0], y = square[1], l = square[2];
+            heights.add((double) y);
+            heights.add((double) (y + l));
+        }
+        
+        Collections.sort(heights);
+        double totalArea = 0;
+        for (int[] square : squares) {
+            totalArea += Math.pow(square[2], 2);
+        }
+        
+        double halfArea = totalArea / 2;
+        double areaAbove = 0, areaBelow = 0;
+        double lastHeight = heights.get(0);
+        
+        for (double height : heights) {
+            if (height == lastHeight) continue;
+            double width = height - lastHeight;
+            areaBelow += calculateArea(squares, lastHeight, height, true);
+            areaAbove += calculateArea(squares, lastHeight, height, false);
+            
+            if (areaAbove >= halfArea) {
+                return lastHeight + (halfArea - areaBelow) / (areaAbove - areaBelow) * width;
+            }
+            lastHeight = height;
+        }
+        
+        return lastHeight;
+    }
+    
+    private double calculateArea(int[][] squares, double line, double nextLine, boolean below) {
+        double area = 0;
+        for (int[] square : squares) {
+            int x = square[0], y = square[1], l = square[2];
+            if (below) {
+                if (y < line) {
+                    area += Math.min(nextLine, y + l) - line > 0 ? (Math.min(nextLine, y + l) - line) * l : 0;
+                }
+            } else {
+                if (y + l > line) {
+                    area += Math.min(nextLine, y + l) - line > 0 ? (Math.min(nextLine, y + l) - line) * l : 0;
+                }
+            }
+        }
+        return area;
+    }
+}

Medium/2026-01-13-3453-Separate-Squares-I/solution.js

@@ -0,0 +1,67 @@
+class Solution {
+    minY(squares) {
+        const events = [];
+        const totalArea = squares.reduce((acc, [x, y, l]) => {
+            events.push([x, y, y + l, 1]);
+            events.push([x + l, y, y + l, -1]);
+            return acc + l * l;
+        }, 0);
+
+        events.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+
+        let currentArea = 0;
+        let lastX = events[0][0];
+        const heightCount = new Map();
+
+        const addHeight = (y1, y2) => {
+            for (let y = y1; y < y2; y++) {
+                heightCount.set(y, (heightCount.get(y) || 0) + 1);
+            }
+        };
+
+        const removeHeight = (y1, y2) => {
+            for (let y = y1; y < y2; y++) {
+                if (heightCount.has(y)) {
+                    heightCount.set(y, heightCount.get(y) - 1);
+                    if (heightCount.get(y) === 0) {
+                        heightCount.delete(y);
+                    }
+                }
+            }
+        };
+
+        for (const [x, y1, y2, type] of events) {
+            const width = x - lastX;
+            if (width > 0) {
+                const heights = Array.from(heightCount.keys()).sort((a, b) => a - b);
+                let areaAbove = 0;
+                let areaBelow = 0;
+                let lastHeight = 0;
+
+                for (const height of heights) {
+                    const heightWidth = height - lastHeight;
+                    if (heightWidth > 0) {
+                        areaBelow += heightWidth * width;
+                    }
+                    lastHeight = height;
+                }
+
+                areaAbove = totalArea - areaBelow;
+
+                if (Math.abs(areaAbove - areaBelow) < 1e-5) {
+                    return (areaAbove + areaBelow) / (2 * width);
+                }
+            }
+
+            if (type === 1) {
+                addHeight(y1, y2);
+            } else {
+                removeHeight(y1, y2);
+            }
+
+            lastX = x;
+        }
+
+        return -1; // Should not reach here
+    }
+}

Medium/2026-01-13-3453-Separate-Squares-I/solution.py

@@ -0,0 +1,33 @@
+class Solution:
+    def separateSquares(self, squares: List[List[int]]) -> float:
+        events = []
+        total_area = 0
+        
+        for x, y, l in squares:
+            events.append((y, l, 1))  # start of square
+            events.append((y + l, l, -1))  # end of square
+            total_area += l * l
+        
+        events.sort()
+        
+        below_area = 0
+        above_area = total_area
+        last_y = events[0][0]
+        
+        for y, l, typ in events:
+            if below_area == above_area:
+                return last_y
+            
+            height = y - last_y
+            if height > 0:
+                below_area += height * (above_area - below_area)
+            
+            if typ == 1:
+                below_area += l * l
+            else:
+                below_area -= l * l
+            
+            above_area = total_area - below_area
+            last_y = y
+        
+        return last_y

README.md

@@ -332,3 +332,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-01-08 — [Max Dot Product of Two Subsequences](https://leetcode.com/problems/max-dot-product-of-two-subsequences/) (Hard) → `Hard/2026-01-08-1458-Max-Dot-Product-of-Two-Subsequences`
 - 2026-01-11 — [Maximal Rectangle](https://leetcode.com/problems/maximal-rectangle/) (Hard) → `Hard/2026-01-11-85-Maximal-Rectangle`
 - 2026-01-12 — [Minimum Time Visiting All Points](https://leetcode.com/problems/minimum-time-visiting-all-points/) (Easy) → `Easy/2026-01-12-1266-Minimum-Time-Visiting-All-Points`
+- 2026-01-13 — [Separate Squares I](https://leetcode.com/problems/separate-squares-i/) (Medium) → `Medium/2026-01-13-3453-Separate-Squares-I`