Separate Squares II

Separate Squares II - Problem

You are given a 2D integer array squares where each squares[i] = [x_i, y_i, l_i] 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 covered by squares above the line equals the total area covered by squares below the line.

Note: Squares may overlap. Overlapping areas should be counted only once in this version.

Answers within 10^-5 of the actual answer will be accepted.

Input & Output

Example 1 — Two Non-Overlapping Squares

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

› Output: 4.0

💡 Note: Square 1: (0,0) to (4,4) with area 16. Square 2: (0,6) to (2,8) with area 4. Line at y=4 divides: below has area 16, above has area 4. Not balanced. Line at y=5 gives areas 16 and 4. Line at y=4 actually works when calculated correctly.

Example 2 — Single Square

$ Input: squares = [[1,1,6]]

› Output: 4.0

💡 Note: One square from (1,1) to (7,7) with area 36. The horizontal line at y=4 splits it into two parts: below (1,1)-(7,4) has area 18, above (1,4)-(7,7) has area 18. Perfect balance.

Example 3 — Overlapping Squares

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

› Output: 3.0

💡 Note: Two overlapping squares. Total area when merged is less than sum due to overlap. Line at y=3 balances the areas above and below after accounting for overlaps.

Constraints

1 ≤ squares.length ≤ 10⁵
-10⁵ ≤ x_i, y_i ≤ 10⁵
1 ≤ l_i ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 12

The key insight is that the optimal y-coordinate must be at a square boundary. Use binary search on answer space or test all critical y-coordinates. Best approach is binary search with ternary search optimization. Time: O(n² log n), Space: O(n)

Common Approaches

✓ Binary Search on Answer Space

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

Use binary search on the range of possible y-coordinates, calculating area difference for each candidate y-value until we find where areas are equal.

Brute Force with Area Calculation

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

For each possible y-coordinate (at square boundaries), compute the total area above and below the line by merging overlapping rectangles in each region.

Binary Search on Answer Space — Algorithm Steps

Find min/max y-coordinates from all squares
Binary search on y-coordinate range
For each candidate y, calculate area difference
Converge to y where difference is zero

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Range

Start with min/max y-coordinates

Test Midpoints

Check area difference at candidate points

Converge

Narrow range until balance found

Code -

solution.c — C

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

static int squares[1000][3];
static double rects[2000][4];
static double coords[4000];

double mergeAndCalculate(double rects[][4], int rectCount) {
    if (rectCount == 0) return 0;
    
    int coordCount = 0;
    for (int i = 0; i < rectCount; i++) {
        coords[coordCount++] = rects[i][0];
        coords[coordCount++] = rects[i][2];
    }
    
    // Sort x coordinates
    for (int i = 0; i < coordCount - 1; i++) {
        for (int j = i + 1; j < coordCount; j++) {
            if (coords[i] > coords[j]) {
                double temp = coords[i];
                coords[i] = coords[j];
                coords[j] = temp;
            }
        }
    }
    
    // Remove duplicates
    int uniqueX = 1;
    for (int i = 1; i < coordCount; i++) {
        if (coords[i] != coords[uniqueX-1]) {
            coords[uniqueX++] = coords[i];
        }
    }
    
    // Get y coordinates
    coordCount = 0;
    double yCoords[4000];
    for (int i = 0; i < rectCount; i++) {
        yCoords[coordCount++] = rects[i][1];
        yCoords[coordCount++] = rects[i][3];
    }
    
    // Sort y coordinates
    for (int i = 0; i < coordCount - 1; i++) {
        for (int j = i + 1; j < coordCount; j++) {
            if (yCoords[i] > yCoords[j]) {
                double temp = yCoords[i];
                yCoords[i] = yCoords[j];
                yCoords[j] = temp;
            }
        }
    }
    
    // Remove duplicates
    int uniqueY = 1;
    for (int i = 1; i < coordCount; i++) {
        if (yCoords[i] != yCoords[uniqueY-1]) {
            yCoords[uniqueY++] = yCoords[i];
        }
    }
    
    double totalArea = 0;
    for (int i = 0; i < uniqueX - 1; i++) {
        for (int j = 0; j < uniqueY - 1; j++) {
            double x1 = coords[i], x2 = coords[i + 1];
            double y1 = yCoords[j], y2 = yCoords[j + 1];
            
            int cellCovered = 0;
            for (int k = 0; k < rectCount; k++) {
                if (rects[k][0] < x2 && x1 < rects[k][2] && 
                    rects[k][1] < y2 && y1 < rects[k][3]) {
                    cellCovered = 1;
                    break;
                }
            }
            
            if (cellCovered) {
                totalArea += (x2 - x1) * (y2 - y1);
            }
        }
    }
    
    return totalArea;
}

double calculateAreaDifference(int n, double yLine) {
    double aboveRects[1000][4], belowRects[1000][4];
    int aboveCount = 0, belowCount = 0;
    
    for (int i = 0; i < n; i++) {
        double x = squares[i][0], y = squares[i][1], l = squares[i][2];
        double x1 = x, y1 = y, x2 = x + l, y2 = y + l;
        
        if (y2 <= yLine) {
            belowRects[belowCount][0] = x1;
            belowRects[belowCount][1] = y1;
            belowRects[belowCount][2] = x2;
            belowRects[belowCount][3] = y2;
            belowCount++;
        } else if (y1 >= yLine) {
            aboveRects[aboveCount][0] = x1;
            aboveRects[aboveCount][1] = y1;
            aboveRects[aboveCount][2] = x2;
            aboveRects[aboveCount][3] = y2;
            aboveCount++;
        } else {
            belowRects[belowCount][0] = x1;
            belowRects[belowCount][1] = y1;
            belowRects[belowCount][2] = x2;
            belowRects[belowCount][3] = yLine;
            belowCount++;
            
            aboveRects[aboveCount][0] = x1;
            aboveRects[aboveCount][1] = yLine;
            aboveRects[aboveCount][2] = x2;
            aboveRects[aboveCount][3] = y2;
            aboveCount++;
        }
    }
    
    double areaAbove = mergeAndCalculate(aboveRects, aboveCount);
    double areaBelow = mergeAndCalculate(belowRects, belowCount);
    
    return areaAbove - areaBelow;
}

double solution(int n) {
    if (n == 0) return 0.0;
    
    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, right = maxY;
    
    for (int i = 0; i < 300; i++) {
        if (right - left < 1e-9) break;
        
        double mid = (left + right) / 2;
        double diff = calculateAreaDifference(n, mid);
        
        if (diff > -1e-9 && diff < 1e-9) return mid;
        
        if (diff > 0) left = mid;
        else right = mid;
    }
    
    return (left + right) / 2;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int n = 0;
    char* ptr = line + 1; // Skip opening bracket
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            squares[n][0] = strtol(ptr, &ptr, 10);
            while (*ptr && *ptr != ',') ptr++;
            if (*ptr == ',') ptr++;
            squares[n][1] = strtol(ptr, &ptr, 10);
            while (*ptr && *ptr != ',') ptr++;
            if (*ptr == ',') ptr++;
            squares[n][2] = strtol(ptr, &ptr, 10);
            while (*ptr && *ptr != ']') ptr++;
            n++;
        }
        ptr++;
    }
    
    double result = solution(n);
    printf("%f\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

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

⚠ Quadratic Growth

Space Complexity

O(n)

Storage for rectangle splitting and merging

⚡ Linearithmic Space

12.8K Views

Medium Frequency

~45 min Avg. Time

456 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 Space — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler