K Closest Points to Origin

K Closest Points to Origin - Problem

Array Math Divide and Conquer Geometry Sorting Heap (Priority Queue) Quickselect Medium

Given an array of points where points[i] = [xi, yi] represents a point on the X-Y plane and an integer k, return the k closest points to the origin (0, 0).

The distance between two points on the X-Y plane is the Euclidean distance (i.e., √(x1 - x2)² + (y1 - y2)²).

You may return the answer in any order. The answer is guaranteed to be unique (except for the order that it is in).

Input & Output

Example 1 — Basic Case

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

› Output: [[1,1],[1,3]]

💡 Note: Distance from origin: [1,1] has distance √2, [3,3] has distance √18, [1,3] has distance √10. The 2 closest are [1,1] and [1,3].

Example 2 — Larger Input

$ Input: points = [[3,3],[5,-1],[-2,4]], k = 2

› Output: [[3,3],[-2,4]]

💡 Note: Distances: [3,3] → √18, [5,-1] → √26, [-2,4] → √20. The 2 closest are [3,3] and [-2,4].

Example 3 — Single Point

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

› Output: [[0,1]]

💡 Note: Only one point exists, so it must be the closest.

Constraints

1 ≤ k ≤ points.length ≤ 10⁴
-10⁴ ≤ xi, yi ≤ 10⁴

Visualization

Tap to expand

Asked in

a Amazon 68 f Facebook 45 G Google 32 M Microsoft 28

The key insight is that we don't need to sort all points - just find the k closest ones. Optimal approach uses quickselect for O(n) average time, while sorting takes O(n log n) and max heap takes O(n log k). Time: O(n), Space: O(log n)

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Max Heap Approach

⏱️ Time: O(n log k) Space: O(k)

Maintain a max heap of size k containing the k closest points seen so far. For each new point, if heap size < k, add it. Otherwise, if current point is closer than the farthest in heap, replace it.

Quickselect (Optimal)

⏱️ Time: O(n) Space: O(log n)

Apply quickselect algorithm to find the kth smallest distance. Partition the array so that the first k elements are the k closest points, without fully sorting them.

Sort All Points

⏱️ Time: O(n log n) Space: O(1)

Calculate the squared distance for each point to origin, sort all points by distance, and return the first k points from the sorted array.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <string.h>

long long power10(int exp) {
    long long result = 1;
    for (int i = 0; i < exp; i++) {
        result *= 10;
    }
    return result;
}

int isPalindrome(long long num) {
    char s[50];
    sprintf(s, "%lld", num);
    int len = strlen(s);
    for (int i = 0; i < len/2; i++) {
        if (s[i] != s[len-1-i]) return 0;
    }
    return 1;
}

long long max(long long a, long long b) {
    return a > b ? a : b;
}

int solution(int n) {
    if (n == 1) return 9;
    
    long long lower = power10(n-1);
    long long upper = power10(n) - 1;
    long long maxPalindrome = 0;
    
    for (long long i = upper; i >= lower; i--) {
        if (i * upper <= maxPalindrome) break;
        for (long long j = i; j >= lower; j--) {
            long long product = i * j;
            if (product <= maxPalindrome) break;
            if (isPalindrome(product)) {
                maxPalindrome = max(maxPalindrome, product);
            }
        }
    }
    
    return maxPalindrome % 1337;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", solution(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

125.0K Views

High Frequency

~15 min Avg. Time

2.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