Separate Squares I

Separate Squares I - Problem

You are given a 2D integer array squares. Each squares[i] = [xi, yi, li] represents the coordinates of the bottom-left point and the side length of a square parallel to the x-axis.

Find the minimum y-coordinate value of a horizontal line such that the total area of the squares above the line equals the total area of the squares below the line.

Note: Squares may overlap. Overlapping areas should be counted multiple times. Answers within 10^-5 of the actual answer will be accepted.

Input & Output

Example 1 — Basic Case

$ Input: squares = [[1,1,3],[1,4,3],[3,1,1]]

› Output: 2.5

💡 Note: Square 1: bottom-left (1,1), area 9. Square 2: bottom-left (1,4), area 9. Square 3: bottom-left (3,1), area 1. At y=2.5: above line = 9+9+1=19, below line = 0. This is just an example - actual calculation considers partial intersections.

Example 2 — Single Square

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

› Output: 2.0

💡 Note: One square from (0,0) to (4,4) with area 16. The horizontal line at y=2 divides it exactly in half: 8 area above, 8 area below.

Example 3 — Non-overlapping

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

› Output: 1.0

💡 Note: Two separate squares, each with area 4. Line at y=1 divides each square in half, giving 4 area above and 4 area below.

Constraints

1 ≤ squares.length ≤ 10⁵
squares[i].length == 3
1 ≤ x_i, y_i, l_i ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 12

The key insight is to find a horizontal line that balances total square areas above and below. The binary search approach is optimal, using O(n log(range)) time by efficiently narrowing down the y-coordinate range while calculating areas at each test point.

Common Approaches

✓ Binary Search on Answer

⏱️ Time: O(n log(max_y)) Space: O(1)

Use binary search on the possible y-coordinate range. For each candidate y, calculate areas above and below, then adjust search range based on which area is larger.

Brute Force - Try All Y-Coordinates

⏱️ Time: O(n²) Space: O(n)

For each possible y-coordinate (square boundaries), calculate total area above and below the line. Find the y where areas are equal.

Binary Search on Answer — Algorithm Steps

Step 1: Find minimum and maximum possible y-coordinates
Step 2: Binary search on this range
Step 3: For each mid-point, calculate area difference and adjust range

Visualization

Tap to expand

Step-by-Step Walkthrough

Set Range

Initial search range from min to max y

Test Middle

Check if areas are balanced at midpoint

Narrow Range

Adjust range based on which area is larger

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

typedef struct {
    double areaAbove;
    double areaBelow;
} Areas;

static int squares[1000][3];

Areas calculateAreas(int n, double lineY) {
    Areas areas = {0.0, 0.0};
    
    for (int i = 0; i < n; i++) {
        int y = squares[i][1], l = squares[i][2];
        double squareBottom = y;
        double squareTop = y + l;
        
        if (lineY <= squareBottom) {
            areas.areaAbove += (double)l * l;
        } else if (lineY >= squareTop) {
            areas.areaBelow += (double)l * l;
        } else {
            double heightBelow = lineY - squareBottom;
            double heightAbove = squareTop - lineY;
            areas.areaBelow += l * heightBelow;
            areas.areaAbove += l * heightAbove;
        }
    }
    
    return areas;
}

double solution(int n) {
    if (n == 0) {
        return 0.0;
    }
    
    // Find search range
    int minY = INT_MAX, maxY = INT_MIN;
    
    for (int i = 0; i < n; i++) {
        int y = squares[i][1], l = squares[i][2];
        if (y < minY) minY = y;
        if (y + l > maxY) maxY = y + l;
    }
    
    double left = minY;
    double right = maxY;
    double eps = 1e-9;
    
    // Binary search for the balance point
    while (right - left > eps) {
        double mid = (left + right) / 2;
        Areas areas = calculateAreas(n, mid);
        
        if (areas.areaAbove > areas.areaBelow) {
            // Too much area above, move line down
            right = mid;
        } else {
            // Too much area below, move line up
            left = mid;
        }
    }
    
    return (left + right) / 2;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int n = 0;
    char *ptr = line;
    
    // Skip initial characters and find first number
    while (*ptr && (*ptr < '0' || *ptr > '9') && *ptr != '-') ptr++;
    
    while (*ptr && n < 1000) {
        long x = strtol(ptr, &ptr, 10);
        while (*ptr && (*ptr < '0' || *ptr > '9') && *ptr != '-') ptr++;
        if (!*ptr) break;
        
        long y = strtol(ptr, &ptr, 10);
        while (*ptr && (*ptr < '0' || *ptr > '9') && *ptr != '-') ptr++;
        if (!*ptr) break;
        
        long l = strtol(ptr, &ptr, 10);
        
        squares[n][0] = (int)x;
        squares[n][1] = (int)y;
        squares[n][2] = (int)l;
        n++;
        
        // Move to next potential number
        while (*ptr && (*ptr < '0' || *ptr > '9') && *ptr != '-') ptr++;
        if (!*ptr) break;
    }
    
    double result = solution(n);
    printf("%f\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log(max_y))

Binary search with log iterations, each requiring O(n) area calculation

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~35 min Avg. Time

890 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 Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler