Find the Number of Ways to Place People I

Find the Number of Ways to Place People I - Problem

Array Math Geometry Sorting Enumeration Medium

Find the Number of Ways to Place People I

You're given a 2D array points of size n x 2 representing integer coordinates of points on a 2D plane, where points[i] = [xi, yi].

Your task is to count the number of valid pairs of points (A, B) where:
• Point A is in the upper-left region relative to point B (meaning A.x ≤ B.x and A.y ≥ B.y)
• The rectangle formed by these two points (including its border) contains no other points except A and B themselves

This is essentially finding pairs of points that can form "clear rectangles" with no obstacles inside.

Goal: Return the total count of such valid pairs.

Input & Output

example_1.py — Basic Case

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

› Output: 0

💡 Note: No valid pairs exist. For (1,1) and (2,2): (1,1) is upper-left of (2,2), but (3,3) lies on the border of their rectangle. For (1,1) and (3,3): (2,2) lies inside their rectangle.

example_2.py — Valid Pairs

$ Input: points = [[6,2],[4,4],[2,6]]

› Output: 2

💡 Note: Two valid pairs: (4,4) and (6,2) form a clear rectangle, and (2,6) and (6,2) form a clear rectangle. The third pair (2,6) and (4,4) has (6,2) inside their rectangle.

example_3.py — Edge Case

$ Input: points = [[0,0],[1,0],[0,1]]

› Output: 3

💡 Note: All three pairs are valid: (0,1)→(0,0), (0,1)→(1,0), and (1,0)→(0,0). Each forms a clear rectangle or line with no other points inside.

Visualization

Tap to expand

Understanding the Visualization

Identify Upper-Left Condition

Point A must have x ≤ B.x and y ≥ B.y

Form Rectangle

Rectangle is defined by corners (A.x, A.y) and (B.x, B.y)

Check for Obstacles

No other points should lie within or on the rectangle border

Count Valid Pairs

Increment counter for each clear rectangle found

Key Takeaway

🎯 Key Insight: We're looking for pairs of points that can form 'empty' rectangles with one point in the upper-left position relative to the other. The challenge is efficiently checking that no other points interfere with each potential rectangle.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n log n) for sorting + O(n³) for checking pairs and rectangles, but with better constants

⚠ Quadratic Growth

Space Complexity

O(1)

Constant extra space if we sort in-place

✓ Linear Space

Constraints

1 ≤ points.length ≤ 50
points[i].length == 2
0 ≤ x_i, y_i ≤ 50
All points are unique

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The key insight is to understand that we need to count pairs where one point is upper-left relative to another, with no obstacles in their rectangle. The brute force approach checks all pairs and validates each rectangle in O(n³) time. An optimized approach uses sorting to reduce redundant checks, though the worst-case complexity remains the same.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized with Sorting	O(n³)	O(1)	Sort points by x-coordinate, then efficiently check rectangles using sweep line
Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check every pair of points and verify no other points lie in their rectangle

Optimized with Sorting — Algorithm Steps

Sort points by x-coordinate (then by y-coordinate for ties)
For each point A, iterate through points B where B.x >= A.x
Check if A.y >= B.y (upper-left condition)
For valid pairs, only check points with x in [A.x, B.x] for rectangle violations
Use the sorted order to break early when possible

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Points

Sort by x-coordinate to process left-to-right

Sweep Right

For each point A, only consider points B to the right

Check Y-condition

Verify A is above or equal to B in y-coordinate

Validate Rectangle

Check only points within the x-range for obstacles

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    int *pa = (int*)a, *pb = (int*)b;
    if (pa[0] == pb[0]) return pa[1] - pb[1];
    return pa[0] - pb[0];
}

int numberOfPointsInRectangle(int points[][2], int n) {
    qsort(points, n, sizeof(int[2]), compare);
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            if (i == j) continue;
            
            int ax = points[i][0], ay = points[i][1];
            int bx = points[j][0], by = points[j][1];
            
            // Check if A is upper-left of B
            if (ay >= by) {
                // Check if rectangle is clear
                bool isClear = true;
                for (int k = 0; k < n; k++) {
                    if (k == i || k == j) continue;
                    
                    int cx = points[k][0], cy = points[k][1];
                    // Only check points within x-range
                    if (ax <= cx && cx <= bx && by <= cy && cy <= ay) {
                        isClear = false;
                        break;
                    }
                }
                
                if (isClear) {
                    count++;
                }
            }
        }
    }
    
    return count;
}

int main() {
    int n;
    scanf("%d", &n);
    int points[n][2];
    for (int i = 0; i < n; i++) {
        scanf("%d %d", &points[i][0], &points[i][1]);
    }
    printf("%d\n", numberOfPointsInRectangle(points, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n log n) for sorting + O(n³) for checking pairs and rectangles, but with better constants

⚠ Quadratic Growth

Space Complexity

O(1)

Constant extra space if we sort in-place

✓ Linear Space

Constraints

1 ≤ points.length ≤ 50
points[i].length == 2
0 ≤ x_i, y_i ≤ 50
All points are unique

21.0K Views

Medium Frequency

~25 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized with Sorting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler