Find the Minimum Possible Sum of a Beautiful Array

Find the Minimum Possible Sum of a Beautiful Array - Problem

Math Greedy Medium

You need to construct a beautiful array of exactly n positive integers that minimizes the total sum.

A beautiful array has three key properties:

Contains exactly n elements
All elements are distinct positive integers
No two elements in the array can sum to the target value

Your goal is to find the minimum possible sum of such an array. Since the result can be large, return it modulo 10⁹ + 7.

Example: If n = 3 and target = 5, you could use [1, 2, 6] (sum = 9) since no pair sums to 5. But [1, 3, 6] wouldn't work because 1 + 4 = 5 isn't satisfied, but we need to be careful about which numbers we can actually include.

Input & Output

example_1.py — Basic Case

$ Input: n = 2, target = 3

› Output: 4

💡 Note: We can choose [1, 2] with sum = 3. We can't choose [1, 2] because 1 + 2 = 3 = target, so we need [1, 4] or [2, 3], etc. Actually, let's verify: we choose [1, 2] but 1+2=3=target, so this violates the condition. We should choose [1, 4] with sum = 5, but actually the minimum is [1, 2] if we reconsider... Let me recalculate: we need pairs that DON'T sum to 3, so [1,2] is invalid. Try [1,4]: 1+4≠3 ✓. But can we do better? [2,4]: 2+4≠3 ✓. Min sum would be 1+4=5. Wait, let me re-read... we want NO pair to sum to target. So [1,4] works with sum 5. But we can also try [1,2] - oh wait, 1+2=3=target, so invalid. What about [2,4]? 2+4=6≠3 ✓. Sum=6. What about [1,4]? 1+4=5≠3 ✓. Sum=5. Even better: what about starting from 1? Pick 1 (forbid 2 since 1+2=3). Then pick 3 (but that would be our target). So pick 4. [1,4] sum=5. Actually optimal might be [1,4] with sum 5. Let me recalculate systematically.

example_2.py — Medium Case

$ Input: n = 3, target = 5

› Output: 6

💡 Note: Using greedy approach: Pick 1 (forbid 4), pick 2 (forbid 3), pick 3 (already forbidden, so skip), pick 4 (forbidden, so skip), pick 5 (no conflict with itself when target=5, but let's be careful about target/2 case), actually pick 6. Wait, let me be more careful. Pick 1 (forbid 4), pick 2 (forbid 3), now we need one more number. 3 is forbidden, 4 is forbidden, so pick 5. But 5+5=10≠5, so 5 is allowed. So [1,2,5] with sum=8. But let's double-check: can we do [1,2,3]? 1+2=3≠5✓, 1+3=4≠5✓, 2+3=5=target✗. So [1,2,3] is invalid. What about [1,2,6]? All pairs: 1+2=3≠5✓, 1+6=7≠5✓, 2+6=8≠5✓. Sum=9. What about [1,4,5]? 1+4=5=target✗. So invalid. Hmm, let me recalculate systematically with the greedy approach.

example_3.py — Edge Case

$ Input: n = 1, target = 2

› Output: 1

💡 Note: With only one element, we can't have any pairs, so any positive integer works. The minimum is 1.

Constraints

2 ≤ n ≤ 10⁵
3 ≤ target ≤ 10⁶
The answer is guaranteed to exist
Result must be returned modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with an empty team and empty forbidden list. Begin checking people from cost 1 upward.

Greedy Selection

For each person, if they're not forbidden, add them to the team and forbid their 'conflict partner'.

Avoid Conflicts

Skip any person who would cause a conflict with someone already on the team.

Complete Team

Continue until you have exactly n people, guaranteed to minimize total cost.

Key Takeaway

🎯 Key Insight: The greedy approach works because choosing the smallest available number at each step, combined with immediately forbidding its complement, ensures we build the lexicographically smallest beautiful array, which automatically has the minimum sum.

Asked in

G Google 12 f Meta 8 a Amazon 6 ⊞ Microsoft 4

The optimal solution uses a greedy approach to construct the beautiful array. Start from 1 and keep selecting the smallest available positive integer that doesn't violate the constraint. When we select a number x, we immediately add target - x to a forbidden set to prevent future conflicts. This ensures we build the lexicographically smallest (and thus minimum sum) beautiful array in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Selection (Optimal)	O(n)	O(n)	Greedily select smallest available numbers while avoiding pairs that sum to target
Brute Force (Generate All Combinations)	O(C(k,n) * n²)	O(n)	Generate all possible combinations of n distinct positive integers and find the one with minimum sum that satisfies the beautiful array condition.

Greedy Selection (Optimal) — Algorithm Steps

Initialize result sum to 0 and a set to track forbidden numbers
Start with current number = 1
For each position in array (n times):
Skip current number if it's in forbidden set
Add current number to result sum
Add its complement (target - current) to forbidden set
Move to next available number
Return the total sum modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Selection

Begin with current=1, forbidden=empty

Check & Add

If current not forbidden, add to result and forbid complement

Skip Forbidden

Skip numbers that would create forbidden pairs

Complete Array

Continue until we have n numbers

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_SIZE 100001

int beautifulArray(int n, int target) {
    bool forbidden[MAX_SIZE] = {false};
    int current = 1;
    long long totalSum = 0;
    int count = 0;
    
    while (count < n && current < MAX_SIZE) {
        if (!forbidden[current]) {
            totalSum = (totalSum + current) % MOD;
            // Add the complement to forbidden set
            int complement = target - current;
            if (complement > 0 && complement != current && complement < MAX_SIZE) {
                forbidden[complement] = true;
            }
            count++;
        }
        current++;
    }
    
    return (int)totalSum;
}

int main() {
    int n, target;
    scanf("[%d, %d]", &n, &target);
    printf("%d\n", beautifulArray(n, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through at most 2n numbers (worst case when target is small), and each operation is O(1)

✓ Linear Growth

Space Complexity

O(n)

In worst case, we store up to n forbidden numbers in the set

⚡ Linearithmic Space

22.5K Views

Medium Frequency

~15 min Avg. Time

890 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

Greedy Selection (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler