Find K Closest Points to the Origin
Given a list of points on the 2-D plane and an integer K. The task is to find K closest points to the origin and print them.
Note: The distance between two points on a plane is the Euclidean distance.
Examples:
Input : point = [[3, 3], [5, -1], [-2, 4]], K = 2 Output : [[3, 3], [-2, 4]] Square of Distance of origin from this point is (3, 3) = 18 (5, -1) = 26 (-2, 4) = 20 So the closest two points are [3, 3], [-2, 4]. Input : point = [[1, 3], [-2, 2]], K = 1 Output : [[-2, 2]] Square of Distance of origin from this point is (1, 3) = 10 (-2, 2) = 8 So the closest point to origin is (-2, 2)
Approach: The idea is to calculate the Euclidean distance from the origin for every given point and sort the array according to the Euclidean distance found. Print the first k closest points from the list.
Algorithm :
Consider two points with coordinates as (x1, y1) and (x2, y2) respectively. The Euclidean distance between these two points will be:
√{(x2-x1)2 + (y2-y1)2}
- Sort the points by distance using the Euclidean distance formula.
- Select first K points form the list
- Print the points obtained in any order.
Note:
- In multimap we can directly store the value of {(x2-x1)2 + (y2-y1)2} instead of its square root because of the following property : If sqrt(x) < sqrt(y) the x < y
- Because of this, we have reduced the time complexity (Time complexity of the square root of an integer is O(√ n) )
Below is the implementation of the above approach:
C++
// C++ program for implementation of // above approach #include<bits/stdc++.h> using namespace std; // Function to print required answer void pClosest(vector<vector< int >> pts, int k) { // In multimap values gets // automatically sorted based on // their keys which is distance here multimap< int , int > mp; for ( int i = 0; i < pts.size(); i++) { int x = pts[i][0], y = pts[i][1]; mp.insert({(x * x) + (y * y) , i}); } for ( auto it = mp.begin(); it != mp.end() && k > 0; it++, k--) cout << "[" << pts[it->second][0] << ", " << pts[it->second][1] << "]" << "\n" ; } // Driver code int main() { vector<vector< int >> points = { { 3, 3 }, { 5, -1 }, { -2, 4 } }; int K = 2; pClosest(points, K); return 0; } // This code is contributed by sarthak_eddy. |
Java
// Java program for implementation of // above approach import java.util.*; class GFG{ // Function to print required answer static void pClosest( int [][]pts, int k) { int n = pts.length; int [] distance = new int [n]; for ( int i = 0 ; i < n; i++) { int x = pts[i][ 0 ], y = pts[i][ 1 ]; distance[i] = (x * x) + (y * y); } Arrays.sort(distance); // Find the k-th distance int distk = distance[k - 1 ]; // Print all distances which are // smaller than k-th distance for ( int i = 0 ; i < n; i++) { int x = pts[i][ 0 ], y = pts[i][ 1 ]; int dist = (x * x) + (y * y); if (dist <= distk) System.out.println( "[" + x + ", " + y + "]" ); } } // Driver code public static void main (String[] args) { int points[][] = { { 3 , 3 }, { 5 , - 1 }, { - 2 , 4 } }; int K = 2 ; pClosest(points, K); } } // This code is contributed by sarthak_eddy. |
Python3
# Python3 program for implementation of # above approach # Function to return required answer def pClosest(points, K): points.sort(key = lambda K: K[ 0 ] * * 2 + K[ 1 ] * * 2 ) return points[:K] # Driver program points = [[ 3 , 3 ], [ 5 , - 1 ], [ - 2 , 4 ]] K = 2 print (pClosest(points, K)) |
C#
// C# program for implementation // of above approach using System; class GFG{ // Function to print // required answer static void pClosest( int [,]pts, int k) { int n = pts.GetLength(0); int [] distance = new int [n]; for ( int i = 0; i < n; i++) { int x = pts[i, 0], y = pts[i, 1]; distance[i] = (x * x) + (y * y); } Array.Sort(distance); // Find the k-th distance int distk = distance[k - 1]; // Print all distances which are // smaller than k-th distance for ( int i = 0; i < n; i++) { int x = pts[i, 0], y = pts[i, 1]; int dist = (x * x) + (y * y); if (dist <= distk) Console.WriteLine( "[" + x + ", " + y + "]" ); } } // Driver code public static void Main ( string [] args) { int [,]points = {{3, 3}, {5, -1}, {-2, 4}}; int K = 2; pClosest(points, K); } } // This code is contributed by Chitranayal |
Javascript
<script> // Javascript program for implementation of // above approach // Function to print required answer function pClosest(pts,k) { let n = pts.length; let distance = new Array(n); for (let i = 0; i < n; i++) { let x = pts[i][0], y = pts[i][1]; distance[i] = (x * x) + (y * y); } distance.sort( function (a,b){ return a-b;}); // Find the k-th distance let distk = distance[k - 1]; // Print all distances which are // smaller than k-th distance for (let i = 0; i < n; i++) { let x = pts[i][0], y = pts[i][1]; let dist = (x * x) + (y * y); if (dist <= distk) document.write( "[" + x + ", " + y + "]<br>" ); } } // Driver code let points = [[3, 3], [5, -1], [-2, 4]]; let K = 2; pClosest(points, K); // This code is contributed by rag2127 </script> |
Output:
[[3, 3], [-2, 4]]
Complexity Analysis:
- Time Complexity: O(n log n).
Time complexity to find the distance from the origin for every point is O(n) and to sort the array is O(n log n) - Space Complexity: O(n).
As we are making an array to store distance from the origin for each point.