Merge pull request #223 from 0xff-dev/973

Add solution and test-cases for problem 973

Author: 6boris

leetcode/901-1000/0973.K-Closest-Points-to-Origin/README.md

@@ -1,26 +1,33 @@
 # [973.K Closest Points to Origin][title]
 
-> [!WARNING|style:flat]
-> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
-
 ## Description
+Given an array of `points` where points[i] = [x<sub>i</sub>, y<sub>i</sub>] represents a point on the **X-Y** plane and an integer `k`, return the `k` closest points to the origin `(0, 0)`.
 
-**Example 1:**
+The distance between two points on the **X-Y** plane is the Euclidean distance (i.e., √(x<sub>1</sub> - x<sub>2</sub>)<sup>2</sup> + (y<sub>1</sub> - y<sub>2</sub>)<sup>2</sup>).
 
-```
-Input: a = "11", b = "1"
-Output: "100"
-```
+You may return the answer in **any order**. The answer is **guaranteed** to be **unique** (except for the order that it is in). 
+
+<br>
 
-## 题意
-> ...
+**Example 1:** 
 
-## 题解
+<img src="./closestplane1.jpg" width=300 height=300> 
 
-### 思路1
-> ...
-K Closest Points to Origin
-```go
+```
+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]]
+Explanation: The answer [[-2,4],[3,3]] would also be accepted.
 ```
 
 

leetcode/901-1000/0973.K-Closest-Points-to-Origin/Solution.go

@@ -1,5 +1,38 @@
 package Solution
 
-func Solution(x bool) bool {
-return x
+func Solution(points [][]int, k int) [][]int {
+result := make([][]int, 0)
+for {
+m := kClosestPartion(points)
+if m == k-1 {
+result = append(result, points[:m+1]...)
+return result
+}
+if m < k {
+result = append(result, points[:m+1]...)
+points = points[m+1:]
+k -= m + 1
+continue
+}
+points = points[:m]
+}
+}
+
+func kClosestPartion(points [][]int) int {
+if len(points) == 0 {
+return 0
+}
+x, y := points[0][0], points[0][1]
+cmpObj, idx := x*x+y*y, 0
+
+for walker := 1; walker < len(points); walker++ {
+x, y = points[walker][0], points[walker][1]
+dis := x*x + y*y
+if dis < cmpObj {
+idx++
+points[idx], points[walker] = points[walker], points[idx]
+}
+}
+points[idx], points[0] = points[0], points[idx]
+return idx
 }

leetcode/901-1000/0973.K-Closest-Points-to-Origin/Solution_test.go

@@ -2,6 +2,7 @@ package Solution
 
 import (
 "reflect"
+"sort"
 "strconv"
 "testing"
 )
@@ -10,18 +11,32 @@ func TestSolution(t *testing.T) {
 //	测试用例
 cases := []struct {
 name string
-inputs bool
-expect bool
+inputs [][]int
+k int
+expect [][]int
 }{
-{"TestCase", true, true},
-{"TestCase", true, true},
-{"TestCase", false, false},
+{"TestCase1", [][]int{{1, 3}, {-2, 2}}, 1, [][]int{{-2, 2}}},
+{"TestCase2", [][]int{{3, 3}, {5, -1}, {-2, 4}}, 2, [][]int{{3, 3}, {-2, 4}}},
+{"TestCase3", [][]int{{3, 3}, {5, -1}, {-2, 4}}, 3, [][]int{{3, 3}, {-2, 4}, {5, -1}}},
 }
 
 //	开始测试
 for i, c := range cases {
 t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
-got := Solution(c.inputs)
+got := Solution(c.inputs, c.k)
+sort.Slice(got, func(i, j int) bool {
+if got[i][0] == got[j][0] {
+return got[i][1] < got[j][1]
+}
+return got[i][0] < got[j][0]
+})
+
+sort.Slice(c.expect, func(i, j int) bool {
+if c.expect[i][0] == c.expect[j][0] {
+return c.expect[i][1] < c.expect[j][1]
+}
+return c.expect[i][0] < c.expect[j][0]
+})
 if !reflect.DeepEqual(got, c.expect) {
 t.Fatalf("expected: %v, but got: %v, with inputs: %v",
 c.expect, got, c.inputs)