LeetCode 1962. Remove Stones to Minimize the Total

Author: raul-sauco

README.md

@@ -354,6 +354,7 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 | [1832. Check if the Sentence Is Pangram][lc1832]                               | 🟢 Easy    | [![python](res/py.png)][lc1832py]                                   |
 | [1899. Merge Triplets to Form Target Triplet][lc1899]                          | 🟠 Medium  | [![python](res/py.png)][lc1899py]                                   |
 | [1926. Nearest Exit from Entrance in Maze][lc1926]                             | 🟠 Medium  | [![python](res/py.png)][lc1926py]                                   |
+| [1962. Remove Stones to Minimize the Total][lc1962]                            | 🟠 Medium  | [![python](res/py.png)][lc1962py]                                   |
 | [1971. Find if Path Exists in Graph][lc1971]                                   | 🟢 Easy    | [![python](res/py.png)][lc1971py]                                   |
 | [1991. Find the Middle Index in Array][lc1991]                                 | 🟢 Easy    | [![python](res/py.png)][lc1991py]                                   |
 | [1996. The Number of Weak Characters in the Game][lc1996]                      | 🟠 Medium  | [![python](res/py.png)][lc1996py]                                   |
@@ -1051,6 +1052,8 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 [lc1899py]: leetcode/merge-triplets-to-form-target-triplet.py
 [lc1926]: https://leetcode.com/problems/nearest-exit-from-entrance-in-maze/
 [lc1926py]: leetcode/nearest-exit-from-entrance-in-maze.py
+[lc1962]: https://leetcode.com/problems/remove-stones-to-minimize-the-total/
+[lc1962py]: leetcode/remove-stones-to-minimize-the-total.py
 [lc1971]: https://leetcode.com/problems/find-if-path-exists-in-graph/
 [lc1971py]: leetcode/find-if-path-exists-in-graph.py
 [lc1991]: https://leetcode.com/problems/find-the-middle-index-in-array/

leetcode/remove-stones-to-minimize-the-total.py

@@ -0,0 +1,111 @@
+# 1962. Remove Stones to Minimize the Total
+# 🟠 Medium
+#
+# https://leetcode.com/problems/remove-stones-to-minimize-the-total/
+#
+# Tags: Array - Heap (Priority Queue)
+
+import timeit
+from heapq import heapify, heapreplace
+from typing import List
+
+
+# Use a heap, ideally a maximum heap, but in Python we can use a minimum
+# heap with negated values to remove half of the stones from the largest
+# pile at each step.
+#
+# Time complexity: O(k*log(n)) - We copy and heapify the input array at
+# O(n), then iterate over it k times pushing and popping from the heap
+# at O(log(n)) cost.
+# Space complexity: O(n) - The values heap has the same size as the
+# input. If we can mutate the input, we could use that array and reduce
+# the complexity to O(1) extra memory.
+#
+# Runtime 1604 ms Beats 100%
+# Memory 28.6 MB Beats 44.43%
+class PriorityQueue:
+    def minStoneSum(self, piles: List[int], k: int) -> int:
+        vals = [-x for x in piles]
+        heapify(vals)
+        for _ in range(k):
+            heapreplace(vals, vals[0] // 2)
+        return -sum(vals)
+
+
+# Use bucket sort, create an array of size 10^4
+#
+# Time complexity: O(k*log(n)) - We copy and heapify the input array at
+# O(n), then iterate over it k times pushing and popping from the heap
+# at O(log(n)) cost.
+# Space complexity: O(n) - The values heap has the same size as the
+# input. If we can mutate the input, we could use that array and reduce
+# the complexity to O(1) extra memory.
+#
+# Runtime 1404 ms Beats 100%
+# Memory 28.3 MB Beats 92.80%
+class BucketSort:
+    def minStoneSum(self, piles: List[int], k: int) -> int:
+        # Create an array of buckets where we will place the number of
+        # piles with that number of elements on them.
+        buckets = [0] * 10001
+        # The value of the greatest pile and the total sum.
+        i = total = 0
+        # Store the number of piles of each size on the buckets.
+        for j in range(len(piles)):
+            buckets[piles[j]] += 1
+            if piles[j] > i:
+                i = piles[j]
+            total += piles[j]
+        # Iterate back over the buckets staying at the biggest pile.
+        while k and i > 1:
+            # If we have cleared all piles size i, move onto the next
+            # greatest size.
+            if buckets[i] == 0:
+                i -= 1
+                continue
+            # This is the number of elements we need to remove from the
+            # current pile of size i.
+            removed = i // 2
+            # The size of the remaining pile after we remove the
+            # elements is j.
+            j = i - removed
+            # After the update, we have one less pile of size i, one
+            # more of size j.
+            buckets[j] += 1
+            buckets[i] -= 1
+            # After the update we have `removed` less elements.
+            total -= removed
+            # We have consumed one update.
+            k -= 1
+        return total
+
+
+def test():
+    executors = [
+        PriorityQueue,
+        BucketSort,
+    ]
+    tests = [
+        [[5, 4, 9], 2, 12],
+        [[10000], 10000, 1],
+        [[4, 3, 6, 7], 3, 12],
+    ]
+    for executor in executors:
+        start = timeit.default_timer()
+        for _ in range(1):
+            for col, t in enumerate(tests):
+                sol = executor()
+                result = sol.minStoneSum(t[0], t[1])
+                exp = t[2]
+                assert result == exp, (
+                    f"\033[93m» {result} <> {exp}\033[91m for"
+                    + f" test {col} using \033[1m{executor.__name__}"
+                )
+        stop = timeit.default_timer()
+        used = str(round(stop - start, 5))
+        cols = "{0:20}{1:10}{2:10}"
+        res = cols.format(executor.__name__, used, "seconds")
+        print(f"\033[92m» {res}\033[0m")
+
+
+test()