feat(data structures, heaps): min cost to connect sticks

Author: BrianLusina

datastructures/trees/heaps/binary/min_heap/__init__.py

@@ -12,6 +12,7 @@ def __init__(self, heap: List[HeapNode] = None):
         self.idx_of_element = {}
         if heap is None:
             heap = []
+        self.heap: List[HeapNode] = []
         self.heap = self.build_heap(heap)
         heapify(self.heap)
 
@@ -97,7 +98,7 @@ def insert_data(self, data: Any):
         """
         if data is None:
             raise TypeError("Data item can not be None")
-        node = HeapNode(data, data.__name__)
+        node = HeapNode(data)
         self.heap.append(node)
         self.__bubble_up(len(self.heap) - 1)
 

datastructures/trees/heaps/node.py

@@ -1,3 +1,4 @@
+from typing import Optional
 from datastructures.trees.binary.tree import BinaryTreeNode, T
 
 
@@ -7,10 +8,31 @@ class HeapNode(BinaryTreeNode):
     a Binary Tree Node which exhibit similar properties.
     """
 
-    def __init__(self, data: T, key: T):
+    def __init__(self, data: T, key: Optional[T] = None):
         super().__init__(data)
         self.key = key
 
     @property
     def name(self):
         return self.__class__.__name__
+
+    def __eq__(self, other: 'HeapNode') -> bool:
+        return self.data == other.data
+
+    def __lt__(self, other: 'HeapNode') -> bool:
+        return self.data < other.data
+
+    def __gt__(self, other: 'HeapNode') -> bool:
+        return self.data > other.data
+
+    def __le__(self, other: 'HeapNode') -> bool:
+        return self.data <= other.data
+
+    def __ge__(self, other: 'HeapNode') -> bool:
+        return self.data >= other.data
+
+    def __ne__(self, other: 'HeapNode') -> bool:
+        return self.data != other.data
+
+    def __hash__(self) -> int:
+        return hash(self.data)

puzzles/heap/min_cost_to_connect_sticks/README.md

@@ -0,0 +1,22 @@
+# Minimum Cost to Connect Sticks
+
+You are given a set of sticks with positive integer lengths represented as an array, sticks, where sticks[i] denotes the
+length of the ith stick.
+
+You can connect any two sticks into one stick at a cost equal to the sum of their lengths. Once two sticks are combined, 
+they form a new stick whose length is the sum of the two original sticks. This process continues until there is only one
+stick remaining.
+
+Your task is to determine the minimum cost required to connect all the sticks into a single stick.
+
+Constraints:
+
+- 1 ≤ sticks.length ≤ 10^3
+- 1 ≤ sticks[i] ≤ 10^3
+
+## Examples
+
+![Example 1](./images/examples/min_cost_to_connect_sticks_1.png)
+![Example 2](./images/examples/min_cost_to_connect_sticks_2.png)
+![Example 3](./images/examples/min_cost_to_connect_sticks_3.png)
+![Example 4](./images/examples/min_cost_to_connect_sticks_4.png)

puzzles/heap/min_cost_to_connect_sticks/__init__.py

@@ -0,0 +1,86 @@
+from typing import List
+from heapq import heapify, heappop, heappush
+from datastructures.trees.heaps.binary.min_heap import MinHeap, HeapNode
+
+
+def connect_sticks(sticks: List[int]) -> int:
+    """
+    Calculates the minimum cost to connect all sticks.
+
+    The function takes a list of integers, representing the length of each stick.
+    It returns an integer representing the minimum cost to connect all sticks.
+
+    The cost to connect two sticks is the sum of their lengths.
+
+    For example, given the list [3, 4, 5], the minimum cost to connect all sticks is 12 (3 + 4 + 5).
+
+    The time complexity of this function is O(nlogn), where n is the number of sticks.
+    The space complexity of this function is O(1), because the heap is built in place from the input list
+    """
+    if len(sticks) <= 1:
+        return 0
+
+    # Create a min heap from the list of sticks
+    heapify(sticks)
+
+    # Initialize the total cost to zero
+    total_cost = 0
+
+    # While there are more than one sticks left
+    while len(sticks) > 1:
+        # Extract the two smallest sticks from the heap
+        first = heappop(sticks)
+        second = heappop(sticks)
+        # Calculate the cost to connect the two sticks
+        cost = first + second
+        # Add the cost to the total cost
+        total_cost += cost
+        # Push the connected stick back into the heap
+        heappush(sticks, cost)
+
+    # Return the total cost
+    return total_cost
+
+
+def connect_sticks_2(sticks: List[int]) -> int:
+    """
+    Calculates the minimum cost to connect all sticks.
+
+    The function takes a list of integers, representing the length of each stick.
+    It returns an integer representing the minimum cost to connect all sticks.
+
+    The cost to connect two sticks is the sum of their lengths.
+
+    For example, given the list [3, 4, 5], the minimum cost to connect all sticks is 12 (3 + 4 + 5).
+
+    The time complexity of this function is O(nlogn), where n is the number of sticks.
+    The space complexity of this function is O(1), because the heap is built in place from the input list
+    """
+    if len(sticks) <= 1:
+        return 0
+
+    nodes: List[HeapNode] = []
+    for stick in sticks:
+        node = HeapNode(stick)
+        nodes.append(node)
+
+    # Create a min heap from the list of sticks
+    min_heap = MinHeap(nodes)
+
+    # Initialize the total cost to zero
+    total_cost = 0
+
+    # While there are more than one sticks left
+    while len(min_heap) > 1:
+        # Extract the two smallest sticks from the heap
+        first = min_heap.remove_min()
+        second = min_heap.remove_min()
+        # Calculate the cost to connect the two sticks
+        cost = first.data + second.data
+        # Add the cost to the total cost
+        total_cost += cost
+        # Push the connected stick back into the heap
+        min_heap.insert_data(cost)
+
+    # Return the total cost
+    return total_cost

puzzles/heap/min_cost_to_connect_sticks/images/examples/min_cost_to_connect_sticks_1.png

@@ -0,0 +1,117 @@
+import unittest
+from . import connect_sticks, connect_sticks_2
+
+
+class MinCostConnectSticksTestCase(unittest.TestCase):
+    def test_1(self):
+        sticks = [3,5,4]
+        expected = 19
+        actual = connect_sticks(sticks)
+        self.assertEqual(expected, actual)
+
+    def test_2(self):
+        sticks = [2,9,4,6]
+        expected = 39
+        actual = connect_sticks(sticks)
+        self.assertEqual(expected, actual)
+
+    def test_3(self):
+        sticks = [23]
+        expected = 0
+        actual = connect_sticks(sticks)
+        self.assertEqual(expected, actual)
+
+    def test_4(self):
+        sticks = [3,3,3]
+        expected = 15
+        actual = connect_sticks(sticks)
+        self.assertEqual(expected, actual)
+
+    def test_5(self):
+        sticks = [1, 10, 3, 3, 3]
+        expected = 40
+        actual = connect_sticks(sticks)
+        self.assertEqual(expected, actual)
+
+    def test_6(self):
+        sticks = [7,10,16]
+        expected = 50
+        actual = connect_sticks(sticks)
+        self.assertEqual(expected, actual)
+
+    def test_7(self):
+        sticks = [5,120,7,30,10]
+        expected = 258
+        actual = connect_sticks(sticks)
+        self.assertEqual(expected, actual)
+
+    def test_8(self):
+        sticks = [100,200,300,400,500]
+        expected = 3300
+        actual = connect_sticks(sticks)
+        self.assertEqual(expected, actual)
+
+    def test_9(self):
+        sticks = [20,20,20,20]
+        expected = 160
+        actual = connect_sticks(sticks)
+        self.assertEqual(expected, actual)
+
+class MinCostConnectSticks2TestCase(unittest.TestCase):
+    def test_1(self):
+        sticks = [3,5,4]
+        expected = 19
+        actual = connect_sticks_2(sticks)
+        self.assertEqual(expected, actual)
+
+    def test_2(self):
+        sticks = [2,9,4,6]
+        expected = 39
+        actual = connect_sticks_2(sticks)
+        self.assertEqual(expected, actual)
+
+    def test_3(self):
+        sticks = [23]
+        expected = 0
+        actual = connect_sticks_2(sticks)
+        self.assertEqual(expected, actual)
+
+    def test_4(self):
+        sticks = [3,3,3]
+        expected = 15
+        actual = connect_sticks_2(sticks)
+        self.assertEqual(expected, actual)
+
+    def test_5(self):
+        sticks = [1, 10, 3, 3, 3]
+        expected = 40
+        actual = connect_sticks_2(sticks)
+        self.assertEqual(expected, actual)
+
+    def test_6(self):
+        sticks = [7,10,16]
+        expected = 50
+        actual = connect_sticks_2(sticks)
+        self.assertEqual(expected, actual)
+
+    def test_7(self):
+        sticks = [5,120,7,30,10]
+        expected = 258
+        actual = connect_sticks_2(sticks)
+        self.assertEqual(expected, actual)
+
+    def test_8(self):
+        sticks = [100,200,300,400,500]
+        expected = 3300
+        actual = connect_sticks_2(sticks)
+        self.assertEqual(expected, actual)
+
+    def test_9(self):
+        sticks = [20,20,20,20]
+        expected = 160
+        actual = connect_sticks_2(sticks)
+        self.assertEqual(expected, actual)
+
+
+if __name__ == '__main__':
+    unittest.main()