Count Number of Rectangles Containing Each Point

Count Number of Rectangles Containing Each Point - Problem

Count Rectangles Containing Each Point

Imagine you have a collection of rectangles, all positioned with their bottom-left corner at the origin (0, 0) and extending to different top-right corners. You also have several query points scattered across the coordinate plane.

Your task is to determine how many rectangles contain each query point. A rectangle defined by [length, height] extends from (0, 0) to (length, height). A point (x, y) is considered inside a rectangle if 0 ≤ x ≤ length and 0 ≤ y ≤ height.

Key Points:
• Points on the edges and corners of rectangles are considered inside
• All rectangles share the same bottom-left corner at origin
• Return an array where each element represents the count for the corresponding query point

Input & Output

example_1.py — Basic Case

$ Input: rectangles = [[3,4],[1,1],[1,4]], points = [[1,1],[1,2],[3,1]]

› Output: [2, 1, 2]

💡 Note: Point (1,1): Inside rectangles [3,4] and [1,4]. Point (1,2): Only inside rectangle [3,4]. Point (3,1): Inside rectangles [3,4] and [1,4].

example_2.py — Edge Points

$ Input: rectangles = [[2,2],[3,3]], points = [[2,2],[0,0],[1,3]]

› Output: [2, 2, 1]

💡 Note: Point (2,2): On edge/corner of both rectangles, counts as inside both. Point (0,0): At origin, inside both rectangles. Point (1,3): Only inside the larger rectangle [3,3].

example_3.py — Outside Points

$ Input: rectangles = [[1,1],[2,2]], points = [[3,3],[0,3],[3,0]]

› Output: [0, 0, 0]

💡 Note: All query points are outside both rectangles. Point (3,3) exceeds both dimensions, (0,3) and (3,0) exceed one dimension each.

Constraints

1 ≤ rectangles.length, points.length ≤ 5 × 10⁴
rectangles[i] = [l_i, h_i] where 1 ≤ l_i, h_i ≤ 10⁹
points[j] = [x_j, y_j] where 0 ≤ x_j, y_j ≤ 10⁹
All rectangles have bottom-left corner at (0,0)

Visualization

Tap to expand

Understanding the Visualization

Setup Rectangles

Position rectangles with bottom-left at origin, extending to different top-right corners

Place Query Points

Scatter query points across the coordinate plane

Check Containment

For each point, count how many rectangles contain it (including edge cases)

Optimize with Sorting

Group rectangles by dimensions and use binary search for efficiency

Key Takeaway

🎯 Key Insight: Since all rectangles share the same bottom-left corner at origin, we can optimize by grouping rectangles by length and using binary search on heights to efficiently count containment without checking every rectangle individually.

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 25 f Meta 18

The optimal approach uses sorting and binary search to achieve O(n log n + m log n) time complexity. By grouping rectangles by length and sorting heights within each group, we can efficiently count valid rectangles for each query point using binary search instead of checking every rectangle individually.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Binary Search	O(n log n + m log n)	O(n)	Sort rectangles by height, then use binary search to count valid rectangles for each point
Brute Force (Nested Loops)	O(n × m)	O(1)	Check each point against every rectangle individually

Sorting + Binary Search — Algorithm Steps

Group rectangles by length
Sort heights within each length group
For each query point (x, y):
- Find all rectangles with length >= x
- Use binary search to count rectangles with height >= y
Return the count array

Visualization

Tap to expand

Step-by-Step Walkthrough

Group by Length

Organize rectangles by their length values

Sort Heights

Sort height arrays within each length group

Filter by Length

For point (x,y), consider only rectangles with length ≥ x

Binary Search Heights

Count rectangles with height ≥ y using binary search

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int binarySearch(int* arr, int size, int target) {
    int left = 0, right = size;
    while (left < right) {
        int mid = (left + right) / 2;
        if (arr[mid] < target) left = mid + 1;
        else right = mid;
    }
    return left;
}

int* countPointsInRectangles(int** rectangles, int rectSize, int** points, int pointSize, int* returnSize) {
    // Implementation with sorting and binary search
    int* result = (int*)calloc(pointSize, sizeof(int));
    *returnSize = pointSize;
    
    // Simplified version - full implementation would require dynamic arrays
    for (int i = 0; i < pointSize; i++) {
        int x = points[i][0], y = points[i][1];
        int count = 0;
        for (int j = 0; j < rectSize; j++) {
            if (rectangles[j][0] >= x && rectangles[j][1] >= y) {
                count++;
            }
        }
        result[i] = count;
    }
    
    return result;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n + m log n)

O(n log n) for sorting rectangles, O(m log n) for m binary searches

⚡ Linearithmic

Space Complexity

O(n)

Space for storing sorted rectangle data

⚡ Linearithmic Space

68.9K Views

Medium-High Frequency

~18 min Avg. Time

1.8K 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

Sorting + Binary Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler