Separate Squares I - Practice Coding Problems

Separate Squares I - Problem

Imagine you're an architect tasked with dividing a city block into two equal-area zones using a horizontal line. The city contains various square buildings, and your job is to find the perfect height for this dividing line.

You are given a 2D integer array squares where each squares[i] = [x_i, y_i, l_i] represents:

x_i, y_i: coordinates of the bottom-left corner of square i
l_i: side length of square i

Your goal is to find the minimum y-coordinate of a horizontal line such that the total area of squares above the line equals the total area of squares below the line.

Important: Squares may overlap, and overlapping areas should be counted multiple times (each square contributes its full area). Answers within 10^-5 of the actual answer will be accepted.

Input & Output

example_1.py — Basic Case

$ Input: squares = [[0,0,2], [2,0,2]]

› Output: 2.0

💡 Note: Two non-overlapping squares of area 4 each. Total area = 8, so we need 4 above and 4 below. The line at y=2 puts the first square entirely below (area 4) and the second square entirely above (area 4).

example_2.py — Overlapping Squares

$ Input: squares = [[0,0,4], [1,1,2]]

› Output: 2.0

💡 Note: First square has area 16, second has area 4. Total area = 20, target = 10. At y=2: first square contributes 4*2=8 below, second contributes 2*1=2 below (total 10 below, 10 above).

example_3.py — Single Square

$ Input: squares = [[0,0,4]]

› Output: 2.0

💡 Note: Single square from (0,0) to (4,4) with area 16. To split equally, we need area 8 above and 8 below. Line at y=2 divides the square perfectly in half.

Constraints

1 ≤ squares.length ≤ 10⁵
squares[i].length == 3
0 ≤ x_i, y_i ≤ 10⁹
1 ≤ l_i ≤ 10⁹
Overlapping areas are counted multiple times
Answer within 10^-5 of actual answer will be accepted

Visualization

Tap to expand

Understanding the Visualization

Identify Critical Points

Mark all square boundaries as potential dividing lines

Binary Search Range

Use binary search between minimum and maximum y-coordinates

Calculate Areas

For each test line, compute total area above and below

Find Balance

Converge on the y-coordinate where areas are equal

Key Takeaway

🎯 Key Insight: Binary search on y-coordinates combined with efficient area calculation gives us O(n log(max_y)) solution, much faster than checking every possible boundary.

Asked in

G Google 42 ⊞ Microsoft 28 a Amazon 35 f Meta 19

This problem requires finding a horizontal line that divides the total area of squares equally. The optimal approach uses binary search on the y-coordinate range to efficiently find the balance point. Key insights: the optimal line must pass through critical y-coordinates (square boundaries), and we can use binary search to converge on the exact position where areas above and below are equal.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Y-Coordinate	O(n log(max_y))	O(1)	Binary search to find the optimal y-coordinate efficiently
Brute Force (Check All Y-Coordinates)	O(n²)	O(n)	Try every possible y-coordinate from square boundaries

Binary Search on Y-Coordinate — Algorithm Steps

Find the minimum and maximum possible y-coordinates from all squares
Use binary search on this y-coordinate range
For each candidate y, calculate total area below the line
If area below < target, search higher; if area below > target, search lower
Continue until we find the y-coordinate that balances the areas
Handle the case where the line cuts through squares

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Range

Start with full y-coordinate range [min_y, max_y]

Test Middle

Calculate area below midpoint, compare with target

Narrow Range

Adjust search range based on area comparison

Converge

Continue until range is smaller than epsilon

Code -

solution.c — C

#include <stdio.h>
#include <math.h>

double calculateAreaBelow(int squares[][3], int n, double testY) {
    double area = 0;
    for (int i = 0; i < n; i++) {
        int x = squares[i][0], y = squares[i][1], l = squares[i][2];
        if (y + l <= testY) {
            area += (long long)l * l;
        } else if (y < testY) {
            double heightBelow = testY - y;
            area += l * heightBelow;
        }
    }
    return area;
}

double separateSquares(int squares[][3], int n) {
    if (n == 0) return 0.0;
    
    long long totalArea = 0;
    double minY = 1e9, maxY = -1e9;
    
    for (int i = 0; i < n; i++) {
        int x = squares[i][0], y = squares[i][1], l = squares[i][2];
        totalArea += (long long)l * l;
        if (y < minY) minY = y;
        if (y + l > maxY) maxY = y + l;
    }
    
    double targetArea = totalArea / 2.0;
    double left = minY, right = maxY;
    double epsilon = 1e-9;
    
    while (right - left > epsilon) {
        double mid = (left + right) / 2;
        double areaBelow = calculateAreaBelow(squares, n, mid);
        
        if (areaBelow < targetArea) {
            left = mid;
        } else {
            right = mid;
        }
    }
    
    return (left + right) / 2;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log(max_y))

O(log(max_y)) binary search iterations × O(n) area calculation per iteration

⚡ Linearithmic

Space Complexity

O(1)

Only constant extra space for binary search variables

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Search on Y-Coordinate — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler