refactor 973

fishercoder1534 · fishercoder1534 · commit 572d2ec639bd · 2019-01-13T08:59:21.000-08:00
diff --git a/src/main/java/com/fishercoder/solutions/_973.java b/src/main/java/com/fishercoder/solutions/_973.java
@@ -3,33 +3,63 @@
 import java.util.Comparator;
 import java.util.PriorityQueue;
 
+/**
+ * 973. K Closest Points to Origin
+ *
+ * We have a list of points on the plane.  Find the K closest points to the origin (0, 0).
+ *
+ * (Here, the distance between two points on a plane is the Euclidean distance.)
+ *
+ * You may return the answer in any order.  The answer is guaranteed to be unique (except for the order that it is in.)
+ *
+ *
+ *
+ * Example 1:
+ *
+ * Input: points = [[1,3],[-2,2]], K = 1
+ * Output: [[-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 closest K = 1 points from the origin, so the answer is just [[-2,2]].
+ * Example 2:
+ *
+ * Input: points = [[3,3],[5,-1],[-2,4]], K = 2
+ * Output: [[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
+ * */
 public class _973 {
 
     public static class Solution1 {
         public int[][] kClosest(int[][] points, int K) {
             int[][] ans = new int[K][2];
 
-            PriorityQueue<int[]> pq = new PriorityQueue<>(new Comparator<int[]>() {
-                @Override
-                public int compare(int[] o1, int[] o2) {
-                    double dist1 = getDistance(o1);
-                    double dist2 = getDistance(o2);
-
-                    if (dist1 > dist2) {
-                        return 1;
-                    } else if (dist1 < dist2) {
-                        return -1;
-                    } else {
-                        return 0;
-                    }
+            PriorityQueue<int[]> pq = new PriorityQueue<>((o1, o2) -> {
+                double dist1 = getDistance(o1);
+                double dist2 = getDistance(o2);
+
+                if (dist1 > dist2) {
+                    return 1;
+                } else if (dist1 < dist2) {
+                    return -1;
+                } else {
+                    return 0;
                 }
             });
 
             for (int[] point : points) {
                 pq.add(point);
             }
 
-            for (int i=0; i<K; i++) {
+            for (int i = 0; i < K; i++) {
                 ans[i] = pq.poll();
             }
 
