update readme

Author: hogan-tech

1014-k-closest-points-to-origin/1014-k-closest-points-to-origin.py

@@ -1,10 +1,23 @@
-# time complexity: O(nlogk)
-# space complexity: O(k)
-from heapq import heapify, heappop
+from heapq import heapify, heappop, heappush
 from math import sqrt
 from typing import List
 
+# time complexity: O(nlogk)
+# space complexity: O(k)
+class Solution:
+    def kClosest(self, points: List[List[int]], k: int) -> List[List[int]]:
+        maxHp = [(-(x ** 2 + y ** 2), x, y) for x, y in points[:k]]
+        heapify(maxHp)
+        for currX, currY in points[k:]:
+            dist = -(currX ** 2 + currY ** 2)
+            if dist > maxHp[0][0]:
+                heappop(maxHp)
+                heappush(maxHp, (dist, currX, currY))
+
+        return [[x, y] for _, x, y in maxHp]
 
+# time complexity: O(nlogn)
+# space complexity: O(k)
 class Solution:
     def kClosest(self, points: List[List[int]], k: int) -> List[List[int]]:
         minHeap = [(sqrt(x**2 + y**2), x, y) for x, y in points]
@@ -15,12 +28,83 @@ def kClosest(self, points: List[List[int]], k: int) -> List[List[int]]:
             result.append([currX, currY])
             k -= 1
         return result
+    
+# time complexity: O(n)
+# space complexity: O(n)
+class Solution:
+    def kClosest(self, points: List[List[int]], k: int) -> List[List[int]]:
+        distances = [self.distance(point) for point in points]
+        remaining = [i for i in range(len(points))]
+        left, right = 0, max(distances)
+        
+        closest = []
+        while k:
+            mid = (left + right) // 2
+            closer, farther = self.splitDis(remaining, distances, mid)
+            if len(closer) > k:
+                remaining = closer
+                right = mid
+            else:
+                k -= len(closer)
+                closest.extend(closer)
+                remaining = farther
+                left = mid
+        return [points[i] for i in closest]
+
+    def splitDis(self, remaining: List[int], distances: List[float],
+                        mid: int) -> List[List[int]]:
+        closer, farther = [], []
+        for index in remaining:
+            if distances[index] <= mid:
+                closer.append(index)
+            else:
+                farther.append(index)
+        return [closer, farther]
 
+    def distance(self, point: List[int]) -> float:
+        return point[0] ** 2 + point[1] ** 2
+
+# time complexity: O(n)
+# space complexity: O(1)
+class Solution:
+    def kClosest(self, points: List[List[int]], k: int) -> List[List[int]]:
+        return self.quickSelect(points, k)
+    
+    def quickSelect(self, points: List[List[int]], k: int) -> List[List[int]]:
+        left, right = 0, len(points) - 1
+        pivotIdx = len(points)
+        while pivotIdx != k:
+            pivotIdx = self.partition(points, left, right)
+            if pivotIdx < k:
+                left = pivotIdx
+            else:
+                right = pivotIdx - 1
+        
+        return points[:k]
+    
+    def partition(self, points: List[List[int]], left: int, right: int) -> int:
+        pivot = self.choosePivot(points, left, right)
+        pivotDis = self.distance(pivot)
+        while left < right:
+            if self.distance(points[left]) >= pivotDis:
+                points[left], points[right] = points[right], points[left]
+                right -= 1
+            else:
+                left += 1
+        
+        if self.distance(points[left]) < pivotDis:
+            left += 1
+        return left
+    
+    def choosePivot(self, points: List[List[int]], left: int, right: int) -> List[int]:
+        return points[left + (right - left) // 2]
+    
+    def distance(self, point: List[int]) -> int:
+        return point[0] ** 2 + point[1] ** 2
 
 points = [[1, 3], [-2, 2]]
 k = 1
 print(Solution().kClosest(points, k))
-
 points = [[3, 3], [5, -1], [-2, 4]]
 k = 2
 print(Solution().kClosest(points, k))

1014-k-closest-points-to-origin/README.md

@@ -115,35 +115,3 @@ It helps others discover the repo and keeps the project growing.
 ---
 
 Feedback / Questions → open an Issue or reach out on [LinkedIn](https://www.linkedin.com/in/hogan-l/)  
-
-<!---LeetCode Topics Start-->
-# LeetCode Topics
-## Array
-|  |
-| ------- |
-| [1014-k-closest-points-to-origin](https://github.com/hogan-tech/leetcode-solution/tree/master/1014-k-closest-points-to-origin) |
-## Math
-|  |
-| ------- |
-| [1014-k-closest-points-to-origin](https://github.com/hogan-tech/leetcode-solution/tree/master/1014-k-closest-points-to-origin) |
-## Divide and Conquer
-|  |
-| ------- |
-| [1014-k-closest-points-to-origin](https://github.com/hogan-tech/leetcode-solution/tree/master/1014-k-closest-points-to-origin) |
-## Geometry
-|  |
-| ------- |
-| [1014-k-closest-points-to-origin](https://github.com/hogan-tech/leetcode-solution/tree/master/1014-k-closest-points-to-origin) |
-## Sorting
-|  |
-| ------- |
-| [1014-k-closest-points-to-origin](https://github.com/hogan-tech/leetcode-solution/tree/master/1014-k-closest-points-to-origin) |
-## Heap (Priority Queue)
-|  |
-| ------- |
-| [1014-k-closest-points-to-origin](https://github.com/hogan-tech/leetcode-solution/tree/master/1014-k-closest-points-to-origin) |
-## Quickselect
-|  |
-| ------- |
-| [1014-k-closest-points-to-origin](https://github.com/hogan-tech/leetcode-solution/tree/master/1014-k-closest-points-to-origin) |
-<!---LeetCode Topics End-->

Python/0973-k-closest-points-to-origin.py

@@ -1,14 +1,14 @@
-<h2> 8586 316
-973. K Closest Points to Origin</h2><hr><div><p>Given an array of <code>points</code> where <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> represents a point on the <strong>X-Y</strong> plane and an integer <code>k</code>, return the <code>k</code> closest points to the origin <code>(0, 0)</code>.</p>
+<h2><a href="https://leetcode.com/problems/k-closest-points-to-origin">1014. K Closest Points to Origin</a></h2><h3>Medium</h3><hr><p>Given an array of <code>points</code> where <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> represents a point on the <strong>X-Y</strong> plane and an integer <code>k</code>, return the <code>k</code> closest points to the origin <code>(0, 0)</code>.</p>
 
-<p>The distance between two points on the <strong>X-Y</strong> plane is the Euclidean distance (i.e., <code>√(x<sub>1</sub> - x<sub>2</sub>)<sup>2</sup> + (y<sub>1</sub> - y<sub>2</sub>)<sup>2</sup></code>).</p>
+<p>The distance between two points on the <strong>X-Y</strong> plane is the Euclidean distance (i.e., <code>&radic;(x<sub>1</sub> - x<sub>2</sub>)<sup>2</sup> + (y<sub>1</sub> - y<sub>2</sub>)<sup>2</sup></code>).</p>
 
 <p>You may return the answer in <strong>any order</strong>. The answer is <strong>guaranteed</strong> to be <strong>unique</strong> (except for the order that it is in).</p>
 
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
-<img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/closestplane1.jpg" style="width: 400px; height: 400px;">
-<pre><strong>Input:</strong> points = [[1,3],[-2,2]], k = 1
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/closestplane1.jpg" style="width: 400px; height: 400px;" />
+<pre>
+<strong>Input:</strong> points = [[1,3],[-2,2]], k = 1
 <strong>Output:</strong> [[-2,2]]
 <strong>Explanation:</strong>
 The distance between (1, 3) and the origin is sqrt(10).
@@ -19,7 +19,8 @@ We only want the closest k = 1 points from the origin, so the answer is just [[-
 
 <p><strong class="example">Example 2:</strong></p>
 
-<pre><strong>Input:</strong> points = [[3,3],[5,-1],[-2,4]], k = 2
+<pre>
+<strong>Input:</strong> points = [[3,3],[5,-1],[-2,4]], k = 2
 <strong>Output:</strong> [[3,3],[-2,4]]
 <strong>Explanation:</strong> The answer [[-2,4],[3,3]] would also be accepted.
 </pre>
@@ -31,4 +32,3 @@ We only want the closest k = 1 points from the origin, so the answer is just [[-
 	<li><code>1 &lt;= k &lt;= points.length &lt;= 10<sup>4</sup></code></li>
 	<li><code>-10<sup>4</sup> &lt;= x<sub>i</sub>, y<sub>i</sub> &lt;= 10<sup>4</sup></code></li>
 </ul>
-</div>