feat(algorithms, heap): construct target with sums

Author: BrianLusina

algorithms/heap/construct_target_with_sums/README.md

@@ -0,0 +1,122 @@
+# Construct Target Array With Multiple Sums
+
+You are given an array `target` of `n` integers. From a starting array `arr` consisting of `n` 1's, you may perform the
+following procedure :
+
+- let x be the sum of all elements currently in your array.
+- choose index i, such that 0 <= i < n and set the value of arr at index i to x.
+- You may repeat this procedure as many times as needed.
+
+Return true if it is possible to construct the target array from arr, otherwise, return false.
+
+## Examples
+
+Example 1:
+
+```text
+Input: target = [9,3,5]
+Output: true
+Explanation: Start with arr = [1, 1, 1] 
+[1, 1, 1], sum = 3 choose index 1
+[1, 3, 1], sum = 5 choose index 2
+[1, 3, 5], sum = 9 choose index 0
+[9, 3, 5] Done
+```
+
+Example 2:
+
+```text
+Input: target = [1,1,1,2]
+Output: false
+Explanation: Impossible to create target array from [1,1,1,1].
+```
+
+Example 3:
+
+```text
+Input: target = [8,5]
+Output: true
+```
+
+## Constraints
+
+- n == target.length
+- 1 <= n <= 5 * 10^4
+- 1 <= target[i] <= 10^9
+
+## Topics
+
+- Array
+- Heap (Priority Queue)
+
+## Hints
+
+- Given that the sum is strictly increasing, the largest element in the target must be formed in the last step by adding
+  the total sum in the previous step. Thus, we can simulate the process in a reversed way.
+- Subtract the largest with the rest of the array, and put the new element into the array. Repeat until all elements
+  become one
+
+## Solution
+
+The straightforward approach starts with an array of all 1’s and replaces one element with the sum of all elements,
+repeating this process. For example, starting with [1, 1, 1, 1], the sum is 4, and one number is replaced with this sum,
+leading to arrays like [4, 1, 1, 1], [1, 4, 1, 1], and so on. This process grows exponentially as the number of possible
+paths increases, making it computationally expensive for larger arrays. The expanding sum makes it hard to predict the
+correct path, and this approach struggles with large arrays due to its high computational cost and inefficiency.
+
+The optimized approach works in reverse, starting from the target array and moving backward toward an array of all 1’s.
+This method reduces the number of possibilities by eliminating unnecessary branching. Instead of growing the array toward
+the target, the algorithm reduces the target by calculating the previous values. At each step, it identifies the largest
+number in the array and computes the sum of the remaining elements.
+
+Instead of directly subtracting the largest number from the sum, the algorithm uses the modulo operation to find the
+previous value by computing the largest number modulo the sum of the other elements. This step-by-step reduction mimics
+working backward through the array, simplifying the array structure. A max heap ensures that the largest number is always
+processed first. This is crucial, as reducing the largest number drives the process toward convergence. The modulo
+operation progressively reduces the largest element, avoiding unnecessary branching and computations. The algorithm
+continues reducing until it reaches an array of all 1’s, confirming the target is achievable, or detects an invalid state,
+signaling failure. This optimized approach handles larger arrays effectively, reducing the largest number step-by-step and
+making the process computationally efficient and scalable. By working backward and minimizing the search space through
+subtraction and modulo, the algorithm ensures a unique path to the target, making it faster and more efficient.
+
+The steps of the algorithm are as follows:
+
+1. Initialize a max-heap and push all elements of the target array into the heap.
+2. Calculate the total_sum of the target array.
+3. Iterate while the max-heap is not empty:
+   - Pop the largest element from the heap (current_max).
+   - Compute the sum of the remaining elements: remaining_sum = total_sum - current_max.
+   - Check for base cases:
+     - If current_max == 1 or remaining_sum == 1, return True, because we can construct the array.
+     - If remaining_sum == 0, or current_max < remaining_sum, or current_max % remaining_sum == 0, return False — it’s
+       invalid or stuck in an infinite loop.
+   - Simulate the reverse of the operation:
+     - Compute the previous value before current_max was formed: updated_value = current_max % remaining_sum.
+     - Update the total sum: total_sum = remaining_sum + updated_value.
+     - Push updated_value back into the heap.
+
+![Solution 1](images/solutions/construct_target_with_sums_solution_1.png)
+![Solution 2](images/solutions/construct_target_with_sums_solution_2.png)
+![Solution 3](images/solutions/construct_target_with_sums_solution_3.png)
+![Solution 4](images/solutions/construct_target_with_sums_solution_4.png)
+![Solution 5](images/solutions/construct_target_with_sums_solution_5.png)
+![Solution 6](images/solutions/construct_target_with_sums_solution_6.png)
+![Solution 7](images/solutions/construct_target_with_sums_solution_7.png)
+![Solution 8](images/solutions/construct_target_with_sums_solution_8.png)
+![Solution 9](images/solutions/construct_target_with_sums_solution_9.png)
+![Solution 10](images/solutions/construct_target_with_sums_solution_10.png)
+![Solution 11](images/solutions/construct_target_with_sums_solution_11.png)
+![Solution 12](images/solutions/construct_target_with_sums_solution_12.png)
+![Solution 13](images/solutions/construct_target_with_sums_solution_13.png)
+![Solution 14](images/solutions/construct_target_with_sums_solution_14.png)
+![Solution 15](images/solutions/construct_target_with_sums_solution_5.png)
+![Solution 16](images/solutions/construct_target_with_sums_solution_16.png)
+
+### Time Complexity
+
+The time complexity of the solution is O(nlog(n)) because each heap operation (push and pop) takes log(n) time and we
+may perform it up to O(n) times in the worst case.
+
+### Space Complexity
+
+The space complexity of the above solution is O(n), for storing the heap.

algorithms/heap/construct_target_with_sums/__init__.py

@@ -0,0 +1,78 @@
+from typing import List
+import heapq
+
+
+def is_possible(target: List[int]) -> bool:
+    if not target:
+        return False
+
+    current_total_sum = sum(target)
+    max_heap = []
+    for x in target:
+        heapq.heappush(max_heap, -x)
+
+    # While the largest element is greater than 1
+    while -max_heap[0] > 1:
+        # Pop the maximum element from the heap
+        current_max = -heapq.heappop(max_heap)
+        # Compute the sum of the remaining elements
+        remaining_sum = current_total_sum - current_max
+
+        if remaining_sum == 1:
+            return True
+
+        if remaining_sum == 0:
+            return False
+
+        # Using modulo % to efficiently reverse multiple subtraction steps at once
+        previous_max = current_max % remaining_sum
+
+        # If the result is invalid (≤ 0 or unchanged), return False.
+        if previous_max == 0 or previous_max >= current_max:
+            return False
+
+        heapq.heappush(max_heap, -previous_max)
+        current_total_sum = remaining_sum + previous_max
+
+    return True
+
+
+def is_possible_2(target: List[int]) -> bool:
+    # Calculate the total sum of the target array
+    total_sum = sum(target)
+
+    # Convert the target array into a max heap by negating the values
+    # (Python's heapq is a min-heap, so we negate to simulate a max-heap)
+    max_heap = [-num for num in target]
+    heapq.heapify(max_heap)  # Turn the list into a heap
+
+    while True:
+        # Pop the largest element (the most negative value, so negate it back)
+        current_max = -heapq.heappop(max_heap)
+
+        # Calculate the sum of the remaining elements (total_sum - current_max)
+        remaining_sum = total_sum - current_max
+
+        # Base cases:
+        # If the current max is 1 or the sum of the remaining elements is 1, we can return True
+        if current_max == 1 or remaining_sum == 1:
+            return True
+
+        # Invalid cases:
+        # If the sum of the remaining elements is 0, or the current max is smaller than
+        # the remaining sum, or the current max divides evenly by the remaining sum, return False
+        if (
+            remaining_sum == 0
+            or current_max < remaining_sum
+            or current_max % remaining_sum == 0
+        ):
+            return False
+
+        # Update the current_max with the modulo of remaining_sum to simulate the "reverse operation"
+        updated_value = current_max % remaining_sum
+
+        # Update the total sum for the next iteration
+        total_sum = remaining_sum + updated_value
+
+        # Push the updated value back into the heap (negate it to keep max-heap behavior)
+        heapq.heappush(max_heap, -updated_value)