Count Number of Rectangles Containing Each Point

Count Number of Rectangles Containing Each Point - Problem

You are given a 2D integer array rectangles where rectangles[i] = [li, hi] indicates that the i-th rectangle has a length of li and a height of hi. You are also given a 2D integer array points where points[j] = [xj, yj] is a point with coordinates (xj, yj).

The i-th rectangle has its bottom-left corner point at the coordinates (0, 0) and its top-right corner point at (li, hi).

Return an integer array count of length points.length where count[j] is the number of rectangles that contain the j-th point.

The i-th rectangle contains the j-th point if 0 <= xj <= li and 0 <= yj <= hi. Note that points that lie on the edges of a rectangle are also considered to be contained by that rectangle.

Input & Output

Example 1 — Basic Rectangle Coverage

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

› Output: [3,3]

💡 Note: Point (1,1) is contained in all 3 rectangles: [3,1] (1≤3, 1≤1), [1,1] (1≤1, 1≤1), [1,2] (1≤1, 1≤2). Point (1,0) is also contained in all 3 rectangles: [3,1] (1≤3, 0≤1), [1,1] (1≤1, 0≤1), [1,2] (1≤1, 0≤2).

Example 2 — Edge and Corner Cases

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

› Output: [1,2,3]

💡 Note: Point (1,1) fits in [1,1], (2,2) fits in [2,2] and [3,3], (0,0) fits in all rectangles as it's at the origin.

Example 3 — Outside All Rectangles

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

› Output: [0,0]

💡 Note: Both points (3,3) and (4,4) are outside all rectangles, so count is 0 for each.

Constraints

1 ≤ rectangles.length ≤ 5 × 10⁴
rectangles[i].length == 2
1 ≤ l_i, h_i ≤ 10⁹
1 ≤ points.length ≤ 5 × 10⁴
points[j].length == 2
0 ≤ x_j, y_j ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 12 f Facebook 10

Brief HTML summary: The key insight is that each rectangle is anchored at origin (0,0), so we only need to check if point coordinates are within the rectangle bounds. The brute force approach checks each point against all rectangles in O(n×m) time. Optimized approaches use sorting and binary search or coordinate compression for faster queries. Best approach depends on input size and query frequency. Time: O(n×m), Space: O(1)

Common Approaches

✓ Frequency Count

⏱️ Time: N/A Space: N/A

Brute Force

⏱️ Time: O(n×m) Space: O(1)

For each point, iterate through all rectangles and count how many contain that point. A rectangle contains a point if the point's x-coordinate is between 0 and rectangle width, and y-coordinate is between 0 and rectangle height.

Coordinate Compression

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

Create a compressed coordinate system using all unique rectangle dimensions and point coordinates. Build a 2D prefix sum array to answer rectangle count queries in O(1) time after preprocessing.

Sorted Binary Search

⏱️ Time: O((m+n) log m) Space: O(m)

Sort rectangles by width and height separately. For each point, use binary search to find how many rectangles have width ≥ x-coordinate and height ≥ y-coordinate, then find intersection.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int rectangles[1000][2];
static int points[1000][2];
static int result[1000];

int parseArray2D(const char* str, int arr[][2]) {
    int count = 0;
    const char* p = str;
    
    // Skip to first '['
    while (*p && *p != '[') p++;
    if (!*p) return 0;
    p++; // skip '['
    
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        
        if (*p == '[') {
            p++; // skip '['
            // Parse first number
            arr[count][0] = (int)strtol(p, (char**)&p, 10);
            
            // Skip comma
            while (*p == ' ' || *p == ',') p++;
            
            // Parse second number
            arr[count][1] = (int)strtol(p, (char**)&p, 10);
            
            // Skip to ']'
            while (*p && *p != ']') p++;
            if (*p == ']') p++;
            
            count++;
        } else if (*p == ']') {
            break;
        } else {
            p++;
        }
    }
    
    return count;
}

int main() {
    char line1[100000], line2[100000];
    
    // Read rectangles
    if (!fgets(line1, sizeof(line1), stdin)) return 1;
    
    // Read points
    if (!fgets(line2, sizeof(line2), stdin)) return 1;
    
    int rectCount = parseArray2D(line1, rectangles);
    int pointCount = parseArray2D(line2, points);
    
    // For each point, count how many rectangles contain it
    for (int j = 0; j < pointCount; j++) {
        int count = 0;
        int px = points[j][0];
        int py = points[j][1];
        
        for (int i = 0; i < rectCount; i++) {
            int length = rectangles[i][0];
            int height = rectangles[i][1];
            
            // Check if point (px, py) is in rectangle from (0,0) to (length, height)
            if (px >= 0 && px <= length && py >= 0 && py <= height) {
                count++;
            }
        }
        
        result[j] = count;
    }
    
    // Output result array
    printf("[");
    for (int i = 0; i < pointCount; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

847 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