Construct Target Array With Multiple Sums

Construct Target Array With Multiple Sums - Problem

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.

Input & Output

Example 1 — Basic Possible Case

$ Input: target = [9,3,5]

› Output: true

💡 Note: Starting from [1,1,1]: Replace index 0 with sum=3 → [3,1,1], then replace index 2 with sum=5 → [3,1,5], finally replace index 0 with sum=9 → [9,3,5]. Working backwards confirms this is possible.

Example 2 — Impossible Case

$ Input: target = [1,1,1,2]

› Output: false

💡 Note: The sum is 5. For 2 to be created, the previous sum must have been 2, but that would require other elements to sum to 0, which is impossible since all elements must be positive.

Example 3 — Single Element

$ Input: target = [8]

› Output: true

💡 Note: Single element case: start with [1], replace with 1 → [1], replace with 1 → [1], ..., eventually we can build up to any positive integer.

Constraints

1 ≤ target.length ≤ 5 × 10⁴
1 ≤ target[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8

The key insight is to work backwards from the target array. The largest element must have been created by replacing some previous element with the sum of all elements. Using a max heap to efficiently process the largest elements, we can reverse-engineer the construction process. Time: O(n log n), Space: O(n)

Common Approaches

✓ Sliding Window

⏱️ Time: N/A Space: N/A

Forward Simulation (Brute Force)

⏱️ Time: O(2^n) Space: O(2^n)

Generate all possible arrays by applying the operation in every possible way. This explores the entire state space but becomes exponentially large.

Reverse Engineering with Max Heap

⏱️ Time: O(n log n) Space: O(n)

The key insight is to work backwards: the largest element in target must have been created by replacing some element with the sum of all elements. Use a max heap to efficiently find and process the largest element.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen