Construct Target Array With Multiple Sums

Construct Target Array With Multiple Sums - Problem

Construct Target Array With Multiple Sums

Imagine you're a mathematician trying to reverse-engineer a sequence! You start with an array arr of n ones: [1, 1, 1, ..., 1]. Your goal is to transform this humble beginning into a given target array through a series of strategic operations.

The Rule: In each step, you can:
1️⃣ Calculate the sum x of all current elements
2️⃣ Pick any index i and replace arr[i] with x

For example, starting with [1, 1, 1]:
• Sum = 3, replace index 0 → [3, 1, 1]
• Sum = 5, replace index 1 → [3, 5, 1]
• Sum = 9, replace index 2 → [3, 5, 9]

Your Mission: Determine if it's possible to construct the given target array using these operations. Return true if possible, false otherwise.

This problem tests your ability to work backwards and understand mathematical relationships!

Input & Output

example_1.py — Python

$ Input: [9,3,5]

› Output: true

💡 Note: Starting from [1,1,1]: sum=3 → [3,1,1], sum=5 → [3,1,5], sum=9 → [3,9,5], sum=17 → [3,5,17]. Wait, this doesn't work. Let's reverse engineer: [9,3,5] → max=9, others=8, previous=1 → [1,3,5] → max=5, others=4, previous=1 → [1,3,1] → max=3, others=2, previous=1 → [1,1,1] ✓

example_2.py — Python

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

› Output: true

💡 Note: Working backwards: [1,1,1,2] → max=2, others=3, previous=-1. This is negative, but we need to check if 2 could come from 1+1+1+1=4 total, so 2 was created when sum was 2+others, meaning 2=sum, so others=0. Actually, let's trace forward: [1,1,1,1] sum=4 → [4,1,1,1] sum=7 → [4,1,1,7] sum=13 → ... This seems impossible. Let me recalculate: if target is [1,1,1,2], the max is 2, others sum to 3, so previous would be 2-3=-1 which is impossible.

example_3.py — Python

$ Input: [8,5]

› Output: true

💡 Note: Reverse engineering: [8,5] → max=8, others=5, previous=8-5=3 → [3,5] → max=5, others=3, previous=5-3=2 → [3,2] → max=3, others=2, previous=3-2=1 → [1,2] → max=2, others=1, previous=2-1=1 → [1,1] ✓

Constraints

1 ≤ target.length ≤ 5 × 10⁴
1 ≤ target[i] ≤ 10⁹
All elements in target are positive integers

Visualization

Tap to expand

Understanding the Visualization

Identify Last Change

The largest element must have been modified most recently

Calculate Previous State

Use math: previous_value = current_max - sum_of_others

Validate & Continue

If previous_value < 1, impossible. Otherwise, repeat process

Reach Base Case

Success when all elements become 1

Key Takeaway

🎯 Key Insight: The largest element in the current state must have been the most recently modified element, allowing us to reverse-engineer the construction process efficiently using mathematical relationships rather than brute force exploration.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

This problem requires reverse engineering the construction process. The optimal approach uses a max heap to always identify the most recently modified element (the largest), then mathematically computes its previous value using the relationship: previous = current_max - sum_of_others. The key insight is that working backwards is much more efficient than trying all forward possibilities. Time complexity is O(n + log(max) × log n) with modulo optimization for large numbers.

Common Approaches

Approach	Time	Space	Notes
✓ Reverse Engineering (Optimal)	O(n + log(max) * log n)	O(n)	Work backwards from target using max heap to determine construction sequence

Reverse Engineering (Optimal) — Algorithm Steps

Use max heap to always get the largest element
Calculate sum of all other elements
Compute what largest element was before last operation
Replace largest element with computed previous value
Repeat until all elements become 1 or impossible case detected

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with target [4,2,3], max=4

Reverse Operation

4 came from sum, so prev = 4 - (2+3) = -1 ❌

Try Different Target

With [9,3,5], max=9, prev = 9 - (3+5) = 1 ✅

Continue Process

Keep reducing until all elements become 1

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    long long* data;
    int size;
    int capacity;
} MaxHeap;

MaxHeap* createHeap(int capacity) {
    MaxHeap* heap = malloc(sizeof(MaxHeap));
    heap->data = malloc(capacity * sizeof(long long));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void heapifyUp(MaxHeap* heap, int idx) {
    while (idx > 0) {
        int parent = (idx - 1) / 2;
        if (heap->data[parent] >= heap->data[idx]) break;
        long long temp = heap->data[parent];
        heap->data[parent] = heap->data[idx];
        heap->data[idx] = temp;
        idx = parent;
    }
}

void heapifyDown(MaxHeap* heap, int idx) {
    while (1) {
        int largest = idx;
        int left = 2 * idx + 1;
        int right = 2 * idx + 2;
        
        if (left < heap->size && heap->data[left] > heap->data[largest])
            largest = left;
        if (right < heap->size && heap->data[right] > heap->data[largest])
            largest = right;
        if (largest == idx) break;
        
        long long temp = heap->data[idx];
        heap->data[idx] = heap->data[largest];
        heap->data[largest] = temp;
        idx = largest;
    }
}

void push(MaxHeap* heap, long long val) {
    heap->data[heap->size] = val;
    heapifyUp(heap, heap->size);
    heap->size++;
}

long long pop(MaxHeap* heap) {
    long long max = heap->data[0];
    heap->data[0] = heap->data[heap->size - 1];
    heap->size--;
    heapifyDown(heap, 0);
    return max;
}

int isPossible(int* target, int n) {
    if (n == 1) return target[0] == 1;
    
    MaxHeap* heap = createHeap(n);
    long long totalSum = 0;
    
    for (int i = 0; i < n; i++) {
        push(heap, target[i]);
        totalSum += target[i];
    }
    
    while (heap->data[0] > 1) {
        long long currentMax = pop(heap);
        long long restSum = totalSum - currentMax;
        
        if (restSum >= currentMax || restSum < 1) {
            free(heap->data);
            free(heap);
            return 0;
        }
        
        if (currentMax > 2 * restSum) {
            currentMax %= restSum;
            if (currentMax == 0) currentMax = restSum;
        }
        
        long long prevValue = currentMax - restSum;
        if (prevValue < 1) {
            free(heap->data);
            free(heap);
            return 0;
        }
        
        push(heap, prevValue);
        totalSum = restSum + prevValue;
    }
    
    free(heap->data);
    free(heap);
    return 1;
}

int main() {
    int n;
    scanf("%d", &n);
    int* target = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &target[i]);
    }
    printf("%s\n", isPossible(target, n) ? "true" : "false");
    free(target);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + log(max) * log n)

O(n) to build heap, then O(log(max)) operations each taking O(log n) for heap operations. With optimization using modulo, it becomes much better.

⚡ Linearithmic

Space Complexity

O(n)

Space for the max heap containing all n elements

⚡ Linearithmic Space

52.3K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Reverse Engineering (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler