We have a list of points in the plane. Find K points closest to
the origin (0, 0).(Here, the distance between two points on a plane is the Euclidean distance
distance.)You can return the answer in any order. The answer is guaranteed to
to be unique (except in the order in which it is)
Example 1
Entry: points = [[1,3],[2,2]], K = 1
Exit:[[[[[2,2]]Explanation:
The distance between (1, 3) and the origin is sqrt (10).
The distance between (2, 2) and the origin is sqrt (8).
Since sqrt (8) <sqrt (10), (2, 2) is closer to the origin.
We only want the K = 1 points closest to the origin, so the answer is just[[[[[2,2]].
Example 2
Entry: points = [[3,3],[5,1],[2,4]], K = 2
Exit: [[3,3],[2,4]](The answer[[[[[2,4],[3,3]]would also be accepted.)
Note:
1 <= K <= points.length <= 10000
10000 <points[i][0] <10000
10000 <points[i][1] <10000
Also note that there may be a situation where the distance of 2 nodes is equal and can therefore print any node.
=======================================
Here is my approach.
 Map of trees taken (so that I can get all sorted distance)
 Start filling in the tree map for all points

Finally took the first element k.
Public class KClosestPointsToOrigin { public int[][] kClosest (int[][] points, int K) { int ranks = points.length; SortedMap <Double, List
> distanceToPoint = new TreeMap <> (); for (int i = 0; i <lines; i ++) { double distance = getDistance (points[i]) if (Objects.nonNull (distanceToPoint.get (distance)))) { listing CoordinatorPointList = distanceToPoint.get (distance); CoordinatePointList.add (new CoordinatePoint (points[i][0]points[i][1])); } other { listing coordinPoints = new ArrayList <> (); CoordinatedPoints.add (new CoordinatePoint (points[i][0]points[i][1])); distanceToPoint.put (distance, coordinatesPoints); // x and y coordinates. } } int[][] arrayToReturn = new int[K][2]; int counter = 0; for (Double key: distanceToPoint.keySet ()) { listing CoordinatedPoints = distanceToPoint.get (key); Iterator iterator1 = CoordinatedPoints.iterator (); while (iterator1.hasNext () && counter <K) { CoordinatePoint coordinPoint = (CoordinatePoint) iterator1.next (); arrayToReturn[counter][0] = coordinPoint.x; arrayToReturn[counter][1] = coordinPoint.y; counter ++; } } return arrayToReturn; } private double getDistance (int[] point) int x = point[0]; int y = point[1]; int x2 = Math.abs (x) * Math.abs (x); int y2 = Math.abs (y) * Math.abs (y); return Math.sqrt (x2 + y2); } }
CoordinatePoint {class
int x;
int y;public CoordinatePoint (int x, int y) { this.x = x; this.y = y; }
}
However, this solution is not effective because the execution and the memory used are important. Can you please help me optimize the solution.