Block Placement Queries - Practice Coding Problems

Block Placement Queries - Problem

Imagine you're managing a construction site on an infinite number line that starts at position 0 and extends infinitely to the right. You need to handle two types of operations:

Type 1: Place Obstacle - [1, x] means you build a permanent obstacle at position x
Type 2: Block Placement Query - [2, x, sz] asks whether you can place a block of size sz anywhere in the range [0, x]

The key constraints are:

A block of size sz occupies positions [start, start + sz]
The entire block must fit within [0, x]
The block cannot intersect with any obstacle, but it can touch obstacles at the endpoints
You don't actually place the block - you just check if it's possible

Goal: Return a boolean array where each entry corresponds to whether a Type 2 query is feasible.

Input & Output

example_1.py — Basic Operations

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

› Output: [true, true]

💡 Note: First, place obstacle at position 2. Then check if we can place block of size 1 in [0,3] - yes, we can place it at [0,1] or [1,2]. Finally, check if we can place block of size 1 in [0,1] - yes, at [0,1].

example_2.py — No Space Available

$ Input: queries = [[1,0],[1,1],[2,1,2]]

› Output: [false]

💡 Note: Place obstacles at positions 0 and 1. Then try to place block of size 2 in [0,1] - impossible because obstacles occupy the entire range.

example_3.py — Multiple Queries

$ Input: queries = [[2,5,2],[1,3],[2,5,2],[1,1],[2,5,2]]

› Output: [true, true, false]

💡 Note: Initially no obstacles, so block of size 2 fits in [0,5]. After adding obstacle at 3, block still fits (e.g., at [0,2]). After adding obstacle at 1, largest gap is only size 1, so block of size 2 won't fit.

Visualization

Tap to expand

Understanding the Visualization

Site Survey

Maintain a sorted list of all existing structures (obstacles) on the construction line

Gap Analysis

For each equipment request, identify all available gaps between structures within the specified range

Size Validation

Check if any gap is large enough to accommodate the requested equipment block

Placement Decision

Return whether placement is possible without actually placing the equipment

Key Takeaway

🎯 Key Insight: Instead of checking every position, we maintain obstacles in sorted order and use binary search to efficiently find gaps. We only need to verify if the largest available gap can accommodate our block size.

Time & Space Complexity

Time Complexity

⏱️

O(Q × N log N)

Q queries, each requiring O(N log N) for binary search and gap checking

⚡ Linearithmic

Space Complexity

O(N)

Store obstacles in sorted order

✓ Linear Space

Constraints

1 ≤ queries.length ≤ 15 × 10⁴
For type 1: queries[i] = [1, x_i] where 0 ≤ x_i ≤ 5 × 10⁴
For type 2: queries[i] = [2, x_i, sz_i] where 0 ≤ x_i, sz_i ≤ 5 × 10⁴
No duplicate obstacles at the same position when type 1 queries are made

Asked in

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

This problem requires dynamic range management with efficient gap finding. The optimal approach uses binary search on sorted obstacles to quickly identify gaps large enough for block placement. Key insight: we only need to find the maximum gap size in the given range, not enumerate all possible positions.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Sorted Obstacles	O(Q × N log N)	O(N)	Sort obstacles and use binary search to efficiently find gaps large enough for each block
Brute Force (Check All Positions)	O(Q × N × X)	O(N)	For each query, check every possible position where the block could fit

Binary Search on Sorted Obstacles — Algorithm Steps

Maintain obstacles in a sorted data structure
For type 1 queries, insert obstacle in sorted order
For type 2 queries, find all gaps in range [0, x] using binary search
Check if any gap is ≥ sz (including gaps at boundaries)
Return true if suitable gap found, false otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Maintain Sorted Obstacles

Keep obstacles in sorted order for efficient gap analysis

Binary Search Boundaries

Use binary search to find obstacle boundaries within range [0, x]

Calculate Gap Sizes

Compute gaps between consecutive obstacles and at boundaries

Check Gap Sufficiency

Verify if any gap is large enough (≥ sz) for the block

Code -

solution.c — C

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

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

bool* solution(int queries[][3], int queryCount, int* returnSize) {
    int obstacles[10000];
    int obstacleCount = 0;
    bool* results = malloc(queryCount * sizeof(bool));
    *returnSize = 0;
    
    for (int i = 0; i < queryCount; i++) {
        if (queries[i][0] == 1) {
            // Add obstacle and maintain sorted order
            obstacles[obstacleCount++] = queries[i][1];
            qsort(obstacles, obstacleCount, sizeof(int), compare);
        } else {
            int x = queries[i][1], sz = queries[i][2];
            bool canPlace = false;
            
            // Check gap from 0 to first obstacle
            if (obstacleCount > 0 && obstacles[0] >= sz) {
                canPlace = true;
            } else if (obstacleCount == 0 && x >= sz) {
                canPlace = true;
            }
            
            // Check gaps between consecutive obstacles
            if (!canPlace) {
                for (int j = 0; j < obstacleCount - 1; j++) {
                    if (obstacles[j] >= x) break;
                    if (obstacles[j + 1] - obstacles[j] >= sz) {
                        canPlace = true;
                        break;
                    }
                }
            }
            
            // Check gap from last obstacle to x
            if (!canPlace && obstacleCount > 0) {
                int lastObs = obstacles[obstacleCount - 1];
                if (lastObs < x && x - lastObs >= sz) {
                    canPlace = true;
                }
            }
            
            results[(*returnSize)++] = canPlace;
        }
    }
    
    return results;
}

int main() {
    int queries[][3] = {{1,2,0},{2,3,1},{2,1,1}};
    int returnSize;
    bool* result = solution(queries, 3, &returnSize);
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", result[i]);
    }
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(Q × N log N)

Q queries, each requiring O(N log N) for binary search and gap checking

⚡ Linearithmic

Space Complexity

O(N)

Store obstacles in sorted order

✓ Linear Space

Constraints

1 ≤ queries.length ≤ 15 × 10⁴
For type 1: queries[i] = [1, x_i] where 0 ≤ x_i ≤ 5 × 10⁴
For type 2: queries[i] = [2, x_i, sz_i] where 0 ≤ x_i, sz_i ≤ 5 × 10⁴
No duplicate obstacles at the same position when type 1 queries are made

51.3K Views

High Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Binary Search on Sorted Obstacles — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler