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 from 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++ 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 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 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# 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 |
<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> |
[[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.