# 1354. Construct Target Array With Multiple Sums

#### Hard

***

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`.

&#x20;

**Example 1:**

```
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:**

```
Input: target = [1,1,1,2]
Output: false
Explanation: Impossible to create target array from [1,1,1,1].
```

**Example 3:**

```
Input: target = [8,5]
Output: true
```

&#x20;

**Constraints:**

* `n == target.length`
* `1 <= n <= 5 * 104`
* `1 <= target[i] <= 109`

#### Time Complexity : O(N) + O(logM)\*O(logN)

Here `logM` refers to line 19 which if kond&#x20;

```python
class Solution:
    def isPossible(self, target: List[int]) -> bool:
        # Pick Largest element from given array
        # Subtract from sum of rest of the elements
        # Keep doing this until all one
        total = sum(target)
        arr = [-num for num in target]
        heapify(arr) # Created Max Heap using negative value
        while True:
            val = -heappop(arr)
            total -= val
            if val == 1 or total == 1:
                return True
            if val < total or total == 0 or val % total == 0:
                return False
            # Earlier I was subtracting total from val which was kind of slow
            # if val is very large and we need to iterate same step multiple times
            # But with % it is fast
            val %= total
            total += val
            heappush(arr, -val)
```