Find the Number of Ways to Place People II

Find the Number of Ways to Place People II - Problem

Array Math Geometry Sorting Enumeration Hard

Imagine you're Alice and you want to build a private rectangular fence around just you and your friend Bob on a 2D plane! 🏠

You're given n points where people must be placed, with exactly one person per point. Alice wants to build a rectangular fence where:

Alice's position is the upper-left corner
Bob's position is the lower-right corner
No other people are inside or on the fence boundary

The fence can be a line (zero area) if Alice and Bob share the same x or y coordinate.

Goal: Count how many valid pairs of positions (Alice, Bob) exist where Alice won't be sad due to unwanted visitors in their private space.

Note: "Upper-left" means Alice's x ≤ Bob's x and Alice's y ≥ Bob's y (remember y-axis increases upward).

Input & Output

example_1.py — Basic Rectangle

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

› Output: 0

💡 Note: No valid Alice-Bob pairs exist because any rectangle formed will contain the middle point (2,2) on its boundary or inside.

example_2.py — Valid Pairs

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

› Output: 2

💡 Note: Two valid pairs: Alice at (2,6) with Bob at (6,2), and Alice at (2,6) with Bob at (4,4). Both form rectangles with no other points inside.

example_3.py — Edge Case

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

› Output: 1

💡 Note: Only one valid pair: Alice at (1,3) and Bob at (3,1). The rectangle formed doesn't contain point (1,1) since it's exactly on the boundary.

Visualization

Tap to expand

Understanding the Visualization

Survey the Land

Identify all possible positions where people must be placed on the 2D plane

Test Alice Position

Pick a potential upper-left corner position for Alice

Find Valid Bob Spot

Look for positions where Bob can be lower-right (x ≥ Alice's x, y ≤ Alice's y)

Check for Intruders

Verify no other people would be inside or on the fence boundary

Count Valid Configurations

Add to total count if the fence configuration is private

Key Takeaway

🎯 Key Insight: Alice needs her position as upper-left corner (x ≤ Bob's x, y ≥ Bob's y) and an empty rectangle interior to be happy with their private space.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) pairs to check × O(n) points to verify for each pair

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

2 ≤ points.length ≤ 50
points[i].length == 2
-10⁹ ≤ x_i, y_i ≤ 10⁹
All points have unique coordinates

Asked in

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

This problem requires checking all pairs of points to see if they can form a valid rectangle with Alice at upper-left and Bob at lower-right. The key insight is ensuring no other points fall inside or on the rectangle boundary. While the brute force approach works by checking every pair against all other points, optimization through sorting and geometric constraints can improve practical performance.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Pairs)	O(n³)	O(1)	Try every pair of points as Alice-Bob positions and check if rectangle is empty
Optimized with Sorting	O(n³)	O(n)	Sort points by coordinates and use geometric properties to reduce checks

Brute Force (Check All Pairs) — Algorithm Steps

Iterate through all pairs of points (i, j) as potential Alice-Bob positions
Check if point i can be upper-left and point j can be lower-right (xi ≤ xj and yi ≥ yj)
For valid pairs, check all other points to see if any lie within the rectangle boundaries
Count pairs where no other points interfere with the fence

Visualization

Tap to expand

Step-by-Step Walkthrough

Pick Alice & Bob

Select two points as potential Alice (upper-left) and Bob (lower-right) positions

Validate Corners

Check if Alice can be upper-left and Bob lower-right (ax ≤ bx, ay ≥ by)

Check Rectangle

Examine every other point to see if it falls inside or on the rectangle boundary

Count Valid Pairs

If no points interfere, increment the valid pair counter

Code -

solution.c — C

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

int numberOfPointsInTheRectangle(int points[][2], int n) {
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; 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];
            
            if (ax > bx || ay < by) continue;
            
            bool valid = true;
            for (int k = 0; k < n; k++) {
                if (k == i || k == j) continue;
                
                int px = points[k][0], py = points[k][1];
                if (ax <= px && px <= bx && by <= py && py <= ay) {
                    valid = false;
                    break;
                }
            }
            
            if (valid) count++;
        }
    }
    
    return count;
}

int main() {
    int points[][2] = {{1,1},{2,2},{3,3}};
    printf("%d\n", numberOfPointsInTheRectangle(points, 3));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) pairs to check × O(n) points to verify for each pair

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

2 ≤ points.length ≤ 50
points[i].length == 2
-10⁹ ≤ x_i, y_i ≤ 10⁹
All points have unique coordinates

26.1K Views

Medium Frequency

~25 min Avg. Time

892 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

Brute Force (Check All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler