feat: add solutions to lc problem: No.0973

No.0973.K Closest Points to Origin

Author: yanglbme

solution/0900-0999/0973.K Closest Points to Origin/README.md

@@ -49,58 +49,65 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：自定义排序**
+
+我们将所有点按照与原点的距离从小到大排序，然后取前 $k$ 个点即可。
+
+时间复杂度 $O(n \times \log n)$，空间复杂度 $O(\log n)$。其中 $n$ 为数组 `points` 的长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def kClosest(self, points: List[List[int]], k: int) -> List[List[int]]:
+        points.sort(key=lambda p: p[0] * p[0] + p[1] * p[1])
+        return points[:k]
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-import java.util.*;
+class Solution {
+    public int[][] kClosest(int[][] points, int k) {
+        Arrays.sort(points, (a, b) -> {
+            int d1 = a[0] * a[0] + a[1] * a[1];
+            int d2 = b[0] * b[0] + b[1] * b[1];
+            return d1 - d2;
+        });
+        return Arrays.copyOfRange(points, 0, k);
+    }
+}
+```
 
-/**
- * @author Furaha Damien
- */
+### **C++**
 
+```cpp
 class Solution {
-
-    // Helper inner class
-    public class Point {
-        int x;
-        int y;
-        int distance;
-
-        public Point(int x, int y, int distance) {
-            this.x = x;
-            this.y = y;
-            this.distance = distance;
-        }
+public:
+    vector<vector<int>> kClosest(vector<vector<int>>& points, int k) {
+        sort(points.begin(), points.end(), [](const vector<int>& a, const vector<int>& b) {
+            return a[0] * a[0] + a[1] * a[1] < b[0] * b[0] + b[1] * b[1];
+        });
+        return vector<vector<int>>(points.begin(), points.begin() + k);
     }
+};
+```
 
-    public int[][] kClosest(int[][] points, int K) {
-
-        PriorityQueue<Point> que = new PriorityQueue<Point>((a, b) -> (a.distance - b.distance));
-        int[][] res = new int[K][2];
-
-        for (int[] temp : points) {
-            int dist = (temp[0] * temp[0] + temp[1] * temp[1]);
-            que.offer(new Point(temp[0], temp[1], dist));
-        }
-        for (int i = 0; i < K; i++) {
-            Point curr = que.poll();
-            res[i][0] = curr.x;
-            res[i][1] = curr.y;
-        }
-        return res;
-    }
+### **Go**
+
+```go
+func kClosest(points [][]int, k int) [][]int {
+	sort.Slice(points, func(i, j int) bool {
+		a, b := points[i], points[j]
+		return a[0]*a[0]+a[1]*a[1] < b[0]*b[0]+b[1]*b[1]
+	})
+	return points[:k]
 }
 ```
 

solution/0900-0999/0973.K Closest Points to Origin/README_EN.md

@@ -46,49 +46,50 @@ We only want the closest k = 1 points from the origin, so the answer is just [[-
 ### **Python3**
 
 ```python
-
+class Solution:
+    def kClosest(self, points: List[List[int]], k: int) -> List[List[int]]:
+        points.sort(key=lambda p: p[0] * p[0] + p[1] * p[1])
+        return points[:k]
 ```
 
 ### **Java**
 
 ```java
-import java.util.*;
+class Solution {
+    public int[][] kClosest(int[][] points, int k) {
+        Arrays.sort(points, (a, b) -> {
+            int d1 = a[0] * a[0] + a[1] * a[1];
+            int d2 = b[0] * b[0] + b[1] * b[1];
+            return d1 - d2;
+        });
+        return Arrays.copyOfRange(points, 0, k);
+    }
+}
+```
 
-/**
- * @author Furaha Damien
- */
+### **C++**
 
+```cpp
 class Solution {
-
-    // Helper inner class
-    public class Point {
-        int x;
-        int y;
-        int distance;
-
-        public Point(int x, int y, int distance) {
-            this.x = x;
-            this.y = y;
-            this.distance = distance;
-        }
+public:
+    vector<vector<int>> kClosest(vector<vector<int>>& points, int k) {
+        sort(points.begin(), points.end(), [](const vector<int>& a, const vector<int>& b) {
+            return a[0] * a[0] + a[1] * a[1] < b[0] * b[0] + b[1] * b[1];
+        });
+        return vector<vector<int>>(points.begin(), points.begin() + k);
     }
+};
+```
 
-    public int[][] kClosest(int[][] points, int K) {
-
-        PriorityQueue<Point> que = new PriorityQueue<Point>((a, b) -> (a.distance - b.distance));
-        int[][] res = new int[K][2];
-
-        for (int[] temp : points) {
-            int dist = (temp[0] * temp[0] + temp[1] * temp[1]);
-            que.offer(new Point(temp[0], temp[1], dist));
-        }
-        for (int i = 0; i < K; i++) {
-            Point curr = que.poll();
-            res[i][0] = curr.x;
-            res[i][1] = curr.y;
-        }
-        return res;
-    }
+### **Go**
+
+```go
+func kClosest(points [][]int, k int) [][]int {
+	sort.Slice(points, func(i, j int) bool {
+		a, b := points[i], points[j]
+		return a[0]*a[0]+a[1]*a[1] < b[0]*b[0]+b[1]*b[1]
+	})
+	return points[:k]
 }
 ```
 

solution/0900-0999/0973.K Closest Points to Origin/Solution.cpp

@@ -0,0 +1,9 @@
+class Solution {
+public:
+    vector<vector<int>> kClosest(vector<vector<int>>& points, int k) {
+        sort(points.begin(), points.end(), [](const vector<int>& a, const vector<int>& b) {
+            return a[0] * a[0] + a[1] * a[1] < b[0] * b[0] + b[1] * b[1];
+        });
+        return vector<vector<int>>(points.begin(), points.begin() + k);
+    }
+};

solution/0900-0999/0973.K Closest Points to Origin/Solution.go

@@ -0,0 +1,7 @@
+func kClosest(points [][]int, k int) [][]int {
+	sort.Slice(points, func(i, j int) bool {
+		a, b := points[i], points[j]
+		return a[0]*a[0]+a[1]*a[1] < b[0]*b[0]+b[1]*b[1]
+	})
+	return points[:k]
+}

solution/0900-0999/0973.K Closest Points to Origin/Solution.java

@@ -1,38 +1,10 @@
-import java.util.*;
-
-/**
- * @author Furaha Damien
- */
-
 class Solution {
-
-    // Helper inner class
-    public class Point {
-        int x;
-        int y;
-        int distance;
-
-        public Point(int x, int y, int distance) {
-            this.x = x;
-            this.y = y;
-            this.distance = distance;
-        }
+    public int[][] kClosest(int[][] points, int k) {
+        Arrays.sort(points, (a, b) -> {
+            int d1 = a[0] * a[0] + a[1] * a[1];
+            int d2 = b[0] * b[0] + b[1] * b[1];
+            return d1 - d2;
+        });
+        return Arrays.copyOfRange(points, 0, k);
     }
-
-    public int[][] kClosest(int[][] points, int K) {
-
-        PriorityQueue<Point> que = new PriorityQueue<Point>((a, b) -> (a.distance - b.distance));
-        int[][] res = new int[K][2];
-
-        for (int[] temp : points) {
-            int dist = (temp[0] * temp[0] + temp[1] * temp[1]);
-            que.offer(new Point(temp[0], temp[1], dist));
-        }
-        for (int i = 0; i < K; i++) {
-            Point curr = que.poll();
-            res[i][0] = curr.x;
-            res[i][1] = curr.y;
-        }
-        return res;
-    }
-}
+}

solution/0900-0999/0973.K Closest Points to Origin/Solution.py

@@ -0,0 +1,4 @@
+class Solution:
+    def kClosest(self, points: List[List[int]], k: int) -> List[List[int]]:
+        points.sort(key=lambda p: p[0] * p[0] + p[1] * p[1])
+        return points[:k]