Random Point in Non-overlapping Rectangles

Random Point in Non-overlapping Rectangles - Problem

Array Math Binary Search Reservoir Sampling Prefix Sum Ordered Set Randomized Medium

Imagine you're designing a random location generator for a video game where players can spawn at any integer coordinate within designated safe zones (rectangles). You need to ensure that every possible spawn point has an equal probability of being selected!

You're given an array of non-overlapping axis-aligned rectangles where each rectangle is defined as [a_i, b_i, x_i, y_i]:

(a_i, b_i) = bottom-left corner
(x_i, y_i) = top-right corner

Your task: Design an algorithm that can pick a random integer point inside the space covered by these rectangles. Points on the perimeter are included, and every integer point should be equally likely to be returned.

Example: If you have rectangles [[1,1,3,3], [2,2,4,4]], your algorithm should be able to return any integer coordinate like [1,1], [3,2], [4,4], etc., with proper probability distribution.

Input & Output

example_1.py — Basic Rectangle Selection

$ Input: rects = [[1,1,3,3]] sol = Solution(rects) sol.pick() # Called multiple times

› Output: [2,1], [1,3], [3,2], etc.

💡 Note: With only one rectangle from (1,1) to (3,3), there are 9 possible integer points: (1,1), (1,2), (1,3), (2,1), (2,2), (2,3), (3,1), (3,2), (3,3). Each should have equal 1/9 probability.

example_2.py — Multiple Rectangles

$ Input: rects = [[1,1,3,3], [2,2,4,4]] sol = Solution(rects) sol.pick() # Called multiple times

› Output: [1,1], [4,4], [2,3], etc.

💡 Note: First rectangle has 9 points, second has 9 points, total 18 points. Each rectangle should be selected with probability proportional to its area (both equal here, so 50% each).

example_3.py — Different Sized Rectangles

$ Input: rects = [[0,0,1,1], [1,0,3,0]] sol = Solution(rects) sol.pick() # Called multiple times

› Output: [0,0], [2,0], [1,1], etc.

💡 Note: First rectangle: 2×2=4 points, second rectangle: 3×1=3 points. First rectangle should be selected ~57% of the time, second ~43% of the time.

Visualization

Tap to expand

Understanding the Visualization

Calculate Rectangle Areas

Each rectangle gets tickets equal to its area (number of integer points)

Build Cumulative Distribution

Create ranges for each rectangle proportional to their areas

Random Selection

Pick a random ticket number from the total pool

Binary Search

Find which rectangle owns that ticket number

Generate Point

Pick a random point within the selected rectangle

Key Takeaway

🎯 Key Insight: Use cumulative area distribution to ensure each integer point has equal probability, regardless of which rectangle it belongs to!

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each pick operation takes constant time

✓ Linear Growth

Space Complexity

O(1)

Only stores the input rectangles array

✓ Linear Space

Constraints

1 ≤ rects.length ≤ 100
rects[i].length == 4
-10⁹ ≤ a_i < x_i ≤ 10⁹
-10⁹ ≤ b_i < y_i ≤ 10⁹
x_i - a_i ≤ 2000
y_i - b_i ≤ 2000
All rectangles are non-overlapping
At most 10⁴ calls will be made to pick

Asked in

G Google 15 f Facebook 12 a Amazon 8 ⊞ Microsoft 6

The optimal solution uses weighted random selection with binary search. First, calculate each rectangle's area and build a cumulative area array. For each pick operation, generate a random number in the total area range and use binary search to find which rectangle it maps to, ensuring each point has equal probability. Time: O(n) init, O(log n) per pick.

Common Approaches

Approach	Time	Space	Notes
✓ Naive Random Selection	O(1)	O(1)	Randomly pick a rectangle, then randomly pick a point within it
Weighted Random with Binary Search (Optimal)	O(n) init, O(log n) pick	O(n)	Use cumulative area distribution with binary search for O(log n) point selection

Naive Random Selection — Algorithm Steps

Randomly select one rectangle from the array
Generate random x coordinate within [a_i, x_i]
Generate random y coordinate within [b_i, y_i]
Return the random point [x, y]

Visualization

Tap to expand

Step-by-Step Walkthrough

Random Rectangle Selection

Each rectangle has 1/n probability regardless of size

Random Point Generation

Points in smaller rectangles get higher probability

Biased Distribution

Final distribution is not uniform across all points

Code -

solution.c — C

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

typedef struct {
    int** rects;
    int rectsSize;
} Solution;

Solution* solutionCreate(int** rects, int rectsSize, int* rectsColSize) {
    Solution* obj = (Solution*)malloc(sizeof(Solution));
    obj->rects = rects;
    obj->rectsSize = rectsSize;
    srand(time(NULL));
    return obj;
}

int* solutionPick(Solution* obj, int* returnSize) {
    *returnSize = 2;
    int* result = (int*)malloc(2 * sizeof(int));
    
    // Randomly select a rectangle (INCORRECT APPROACH)
    int rectIdx = rand() % obj->rectsSize;
    int* rect = obj->rects[rectIdx];
    int a = rect[0], b = rect[1], x = rect[2], y = rect[3];
    
    // Generate random point within the rectangle
    result[0] = rand() % (x - a + 1) + a;
    result[1] = rand() % (y - b + 1) + b;
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each pick operation takes constant time

✓ Linear Growth

Space Complexity

O(1)

Only stores the input rectangles array

✓ Linear Space

Constraints

1 ≤ rects.length ≤ 100
rects[i].length == 4
-10⁹ ≤ a_i < x_i ≤ 10⁹
-10⁹ ≤ b_i < y_i ≤ 10⁹
x_i - a_i ≤ 2000
y_i - b_i ≤ 2000
All rectangles are non-overlapping
At most 10⁴ calls will be made to pick

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

Naive Random Selection — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler