refactor(datastructures, algorithms, heaps): add variation and doc to min cost to hire k workers

Author: BrianLusina

algorithms/heap/min_cost_hire_k_workers/README.md

@@ -30,3 +30,51 @@ Explanation: We pay 4 to 0th worker, 13.33333 to 2nd and 3rd workers separately.
 - Greedy
 - Sorting
 - Heap(Priority Queue)
+
+## Solution
+
+This solution uses the top k elements pattern, commonly used when selecting the top k items based on a certain criterion.
+Here, we need to form a group of exactly k workers and minimize the total cost while ensuring fair payments based on the
+workers’ wage expectations and quality. Below are some key observations that will help us to solve the problem:
+
+1. **Proportionality condition**: All workers in the group must be paid proportionally to their quality. If one worker’s
+   quality is twice that of another, they must be paid twice as much.
+2. **Wage-to-quality ratio**: For each worker, we calculate a ratio that indicates how much we need to pay per unit of
+   quality. This ratio is defined as: `ratio[i] = wage[i]/quality[i]`
+3. **Greedy approach:** To minimize the total wage, we process workers based on their wage-to-quality ratios in ascending
+   order. Once we select k workers, we fix the highest wage-to-quality ratio among them. All workers are paid according
+   to this ratio, ensuring proportionality.
+4. **Optimization using a heap**: We can use a max heap to efficiently manage the total quality of selected workers. This
+   allows us to keep track of the workers with the smallest total quality, which is important for minimizing the total
+   wage. The max heap allows us to quickly access the largest quality (at the top of the heap) and remove it in constant
+   time, ensuring that only k workers remain.
+
+The steps of the algorithm are as below:
+
+1. Creates a list of tuple workers for each worker. Sort these tuples based on the ratios in ascending order to process
+   workers with the lowest ratio first. Each tuple contains:
+   - The worker’s wage-to-quality ratio (w/q)
+   - The worker’s quality (q)
+2. Create a max heap `heap` to store the qualities of the selected workers.
+3. Initialize the below variables:
+   - A variable total_quality is used to track the total quality of the workers in the heap
+   - A variable min_cost to store the minimum cost encountered during the process
+4. Iterate through the sorted list of workers based on their ratios. For each worker:
+   - Add their quality (as a negative value to simulate max heap behavior) to the heap.
+   - Update the total_quality by adding the current worker’s quality.
+5. After adding a worker, check if the heap contains more than k workers. If so, remove the worker with the highest
+   quality (i.e., the smallest negative value) to minimize the total quality used in cost calculations.
+6. Once the heap contains exactly k workers, compute the cost of hiring them. This is done by multiplying the highest
+   wage-to-quality ratio (of the current worker) by the total_quality of the selected group. Update the min_cost if the
+   current one is lower than the previously recorded minimum.
+7. After processing all workers, return the min_cost calculated.
+
+### Time Complexity
+
+Sorting the workers takes `O(nlog(n))` time, and maintaining the heap takes `O(klog(k))` time where n is the total number
+of elements in workers and k is the number of workers we want to hire. Hence, the overall time complexity is `O(nlog(n))`
+
+### Space Complexity
+
+We use additional space for the list of all workers (`O(n)`) and for the heap, which contains at most k workers (`O(k)`).
+Since `k≤n`, the overall space complexity is `O(n)`.

algorithms/heap/min_cost_hire_k_workers/__init__.py

@@ -22,3 +22,31 @@ def min_cost_to_hire_workers(quality: List[int], wage: List[int], k: int) -> flo
             quality_sum -= -heappop(worker_pool)
 
     return float(result)
+
+
+def min_cost_to_hire_workers_2(quality, wage, k):
+    # Step 1: Create a list of tuples with (wage/quality ratio, quality) for each worker
+    workers = sorted([(w / q, q) for w, q in zip(wage, quality)])
+
+    heap = []  # A max-heap (using negative values for qualities)
+    total_quality = 0  # Sum of the qualities of the selected workers
+    min_cost = float('inf')  # Initialize the minimum cost to infinity
+
+    # Step 2: Iterate through each worker sorted by their wage-to-quality ratio
+    for ratio, q in workers:
+        # Add the worker's quality to the heap (negative to simulate a max-heap)
+        heappush(heap, -q)
+        total_quality += q  # Add the worker's quality to the total quality
+
+        # Step 3: If we have more than k workers, remove the one with the largest quality
+        if len(heap) > k:
+            # Remove the largest quality (smallest negative number)
+            total_quality += heappop(heap)  # Adding the negative value back
+
+        # Step 4: If we have exactly k workers, calculate the cost
+        if len(heap) == k:
+            # The cost is the current ratio multiplied by the total quality of k workers
+            min_cost = min(min_cost, ratio * total_quality)
+
+    # Step 5: Return the minimum cost found
+    return min_cost

algorithms/heap/min_cost_hire_k_workers/test_min_cost_to_hire_workers.py

@@ -1,25 +1,32 @@
 import unittest
-from . import min_cost_to_hire_workers
+from typing import List
+from parameterized import parameterized
+from algorithms.heap.min_cost_hire_k_workers import min_cost_to_hire_workers, min_cost_to_hire_workers_2
+
+MIN_COST_TO_HIRE_K_WORKERS_TEST_CASES = [
+    ([10, 20, 5], [70, 50, 30], 2, 105.00000),
+    ([3, 1, 10, 10, 1], [4, 8, 2, 2, 7], 3, 30.66667),
+    ([10, 10, 10], [50, 60, 70], 2, 120.00000),
+    ([2, 3, 1], [5, 6, 2], 2, 7.50000),
+    ([5, 9, 4], [50, 45, 30], 3, 180.00000),
+    ([7, 8, 6, 10], [70, 90, 80, 100], 2, 168.75000),
+]
 
 
 class MinCostToHireWorkersTestCase(unittest.TestCase):
-    def test_1(self):
-        """quality = [10,20,5], wage = [70,50,30], k = 2 returns 105.00000"""
-        quality = [10, 20, 5]
-        wage = [70, 50, 30]
-        k = 2
-        expected = 105.00000
+    @parameterized.expand(MIN_COST_TO_HIRE_K_WORKERS_TEST_CASES)
+    def test_min_cost_to_hire_k_workers(
+        self, quality: List[int], wage: List[int], k: int, expected: float
+    ):
         actual = min_cost_to_hire_workers(quality, wage, k)
-        self.assertEqual(expected, actual)
+        self.assertEqual(expected, round(actual, 5))
 
-    def test_2(self):
-        """quality = [3,1,10,10,1], wage = [4,8,2,2,7], k = 3 returns 30.66667"""
-        quality = [3, 1, 10, 10, 1]
-        wage = [4, 8, 2, 2, 7]
-        k = 3
-        expected = 30.66667
-        actual = round(min_cost_to_hire_workers(quality, wage, k), 5)
-        self.assertEqual(expected, actual)
+    @parameterized.expand(MIN_COST_TO_HIRE_K_WORKERS_TEST_CASES)
+    def test_min_cost_to_hire_k_workers_2(
+        self, quality: List[int], wage: List[int], k: int, expected: float
+    ):
+        actual = min_cost_to_hire_workers_2(quality, wage, k)
+        self.assertEqual(expected, round(actual, 5))
 
 
 if __name__ == "__main__":

datastructures/stacks/minstack/README.md

@@ -1,3 +1,5 @@
+# Min Stack
+
 Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.
 
 Implement the MinStack class: