added K Closest Points to Origin (medium)

Author: minhyeong-joe

Medium/KClosestPointsToOrigin/README.md

@@ -0,0 +1,35 @@
+# K Closest Points to Origin
+
+[Leetcode Link](https://leetcode.com/problems/k-closest-points-to-origin/)
+
+## Problem:
+
+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:
+
+```
+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]].
+```
+
+```
+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

Medium/KClosestPointsToOrigin/solution.py

@@ -0,0 +1,64 @@
+from typing import List
+
+
+class MaxHeap():
+ def __init__(self):
+ self.heap = []
+
+ def insert(self, val):
+ self.heap.append(val)
+ self.heapify()
+
+ def getMax(self):
+ return self.heap[0]
+
+ def popMax(self):
+ maxVal = self.heap.pop(0)
+ self.heapify()
+
+ def size(self):
+ return len(self.heap)
+
+ def heapify(self):
+ for i in range(len(self.heap)-1, 0, -1):
+ parentIndex = (i-1) // 2
+ if self.heap[i][0] > self.heap[parentIndex][0]:
+ self.heap[i], self.heap[parentIndex] = self.heap[parentIndex], self.heap[i]
+
+ def __str__(self):
+ return str(self.heap)
+
+ def __iter__(self):
+ return (x for x in self.heap)
+
+
+class Solution:
+ def kClosest(self, points: List[List[int]], K: int) -> List[List[int]]:
+ closest = list(list())
+ # find Euclidean distance and put them in key value pair
+ distances = []
+ for point in points:
+ squareSum = point[0]**2 + point[1]**2
+ distances.append((squareSum, point))
+ print(distances)
+ # use max heap of size K to only hold K closest pairs
+ maxHeap = MaxHeap()
+ for distance, point in distances:
+ # print(distance, point)
+ # if maxheap has space, then insert
+ if maxHeap.size() < K:
+ maxHeap.insert((distance, point))
+ else:
+ if distance < maxHeap.getMax()[0]:
+ maxHeap.popMax()
+ maxHeap.insert((distance, point))
+ # return all K pairs in max heap
+ print([pair[1] for pair in maxHeap])
+ closest.extend([pair[1] for pair in maxHeap])
+ return closest
+
+
+sol = Solution()
+points = [[3, 3], [5, -1], [-2, 4], [3, 4], [1, 5], [-2, -5], [0, 8]]
+K = 4
+print(sol.kClosest(points, K))

README.md

@@ -84,6 +84,7 @@ Languages used: Java and Python
  - [Perfect Squares](Medium/PerfectSquares)
  - [Score After Flipping Matrix](Medium/ScoreAfterFlippingMatrix)
  - [Construct Binary Tree from Preorder and Inorder Traversal](Medium/ConstructBinaryTree)
+ - [K Closest Points to Origin](Medium/KClosestPointsToOrigin)
 - Hard
  - [Maximum Score Words Formed by Letters](Hard/MaximumScoreWords)
  - [Reducing Dishes](Hard/ReducingDishes)