K-th Nearest Obstacle Queries - Practice Coding Problems

K-th Nearest Obstacle Queries - Problem

Imagine you're a city planner working on an infinite 2D grid where new buildings (obstacles) are being constructed one by one. After each new building is placed, you need to quickly determine the k-th closest building to the city center (origin) using Manhattan distance.

You'll receive a series of queries where each query [x, y] represents placing a new obstacle at coordinate (x, y). After each placement, calculate the Manhattan distance |x| + |y| from the origin to the k-th nearest obstacle.

Goal: Return an array where each element represents the distance to the k-th nearest obstacle after each query, or -1 if fewer than k obstacles exist.

Example: If k=2 and you place obstacles at (1,1), (2,2), (3,3), the results would be [-1, 4, 4] because initially there's only 1 obstacle, then the 2nd nearest has distance 4, and it remains 4 after the third placement.

Input & Output

example_1.py — Basic Case

$ Input: k = 3, queries = [[1,2],[3,4],[2,3],[-3,0]]

› Output: [-1, -1, 7, 5]

💡 Note: Query 1: distance = |1|+|2| = 3, only 1 obstacle, k=3 → -1. Query 2: distances = [3,7], only 2 obstacles, k=3 → -1. Query 3: distances = [3,5,7], 3rd nearest = 7. Query 4: distances = [3,3,5,7], 3rd nearest = 5.

example_2.py — Edge Case k=1

$ Input: k = 1, queries = [[5,5],[4,4],[3,3]]

› Output: [10, 8, 6]

💡 Note: With k=1, we always want the nearest obstacle. Query 1: nearest = 10. Query 2: distances = [8,10], nearest = 8. Query 3: distances = [6,8,10], nearest = 6.

example_3.py — Same Distance

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

› Output: [-1, 2, 2]

💡 Note: Query 1: distance = 2, only 1 obstacle → -1. Query 2: distances = [2,2], 2nd nearest = 2. Query 3: distances = [2,2,2], all equal, 2nd nearest = 2.

Constraints

1 ≤ k ≤ 10⁵
1 ≤ queries.length ≤ 2 × 10⁴
All queries[i] are unique
-10⁹ ≤ queries[i][0], queries[i][1] ≤ 10⁹
No obstacle exists at a coordinate when it's being placed

Visualization

Tap to expand

Understanding the Visualization

Station Placement

A new emergency station is built at coordinates (x,y)

Distance Calculation

Calculate Manhattan distance |x| + |y| from city center

Heap Evaluation

Check if this station should be in our 'top k closest' list

Update Response Plan

Report the k-th closest station distance for resource planning

Key Takeaway

🎯 Key Insight: Using a max-heap of size k allows us to efficiently track only the k nearest distances without sorting all obstacles after each placement, reducing complexity from O(n² log n) to O(n log k).

Asked in

G Google 42 a Amazon 38 Apple 25 ⊞ Microsoft 31

The optimal solution uses a max-heap of size k to efficiently track the k nearest obstacle distances. Instead of sorting all distances after each query (O(n² log n)), we maintain only the k smallest distances using heap operations (O(n log k)). The key insight is that we only need to update our tracking when a new obstacle is closer than our current k-th nearest distance.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Sort After Each Query)	O(n² log n)	O(n)	Store all distances and sort completely after each new obstacle
Max-Heap Optimization (Optimal)	O(n log k)	O(k)	Maintain a max-heap of size k to track the k nearest distances efficiently

Brute Force (Sort After Each Query) — Algorithm Steps

Add new obstacle coordinates to a list
Calculate Manhattan distance for all obstacles
Sort all distances in ascending order
Return k-th element if it exists, otherwise -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Add Obstacle

Place new obstacle and calculate its distance

Sort All Distances

Sort complete list of distances from all obstacles

Find K-th Element

Return the k-th element from sorted list

Code -

solution.c — C

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

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

int* solution(int k, int** queries, int queriesSize, int* returnSize) {
    int* results = (int*)malloc(queriesSize * sizeof(int));
    int* distances = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        for (int j = 0; j <= i; j++) {
            distances[j] = abs(queries[j][0]) + abs(queries[j][1]);
        }
        
        qsort(distances, i + 1, sizeof(int), compare);
        
        if (i + 1 >= k) {
            results[i] = distances[k - 1];
        } else {
            results[i] = -1;
        }
    }
    
    free(distances);
    return results;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

For n queries, each query triggers O(n log n) sorting, resulting in O(n² log n) total

⚠ Quadratic Growth

Space Complexity

O(n)

Store coordinates and distances for all n obstacles

⚡ Linearithmic Space

73.4K Views

Medium-High Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Sort After Each Query) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler