Minimum Difference in Sums After Removal of Elements

Minimum Difference in Sums After Removal of Elements - Problem

Imagine you have an array of 3 * n integers, and you're challenged to create the most balanced split possible. Your mission is to remove exactly n elements, then divide the remaining 2 * n elements into two equal groups.

The twist? You want to minimize the absolute difference between the sums of these two groups. The first n elements (in order) form the first group, and the next n elements form the second group.

Goal: Find the minimum possible value of sum_first - sum_second after strategically removing n elements.

Example: If nums = [3,1,2,4,6,5] and n = 2, you could remove [3,6] to get [1,2,4,5]. Then split into first group [1,2] (sum=3) and second group [4,5] (sum=9), giving difference 3-9 = -6.

Input & Output

example_1.py — Basic Case

$ Input: nums = [3,1,2,4,6,5], n = 2

› Output: -6

💡 Note: Remove [3,6] to get [1,2,4,5]. First group [1,2] has sum 3, second group [4,5] has sum 9. Difference is 3-9 = -6.

example_2.py — Another Split

$ Input: nums = [7,9,8,6,2,1], n = 2

› Output: 1

💡 Note: Remove [7,9] to get [8,6,2,1]. First group [8,6] has sum 14, second group [2,1] has sum 3. Difference is 14-3 = 11. But removing [8,2] gives [7,9,6,1] with groups [7,9] (sum=16) and [6,1] (sum=7), difference = 16-7 = 9. Optimal is removing [9,8] to get [7,6,2,1] with difference 13-3 = 10. Actually optimal is removing [6,1] to get [7,9,8,2] with groups [7,9] and [8,2], giving 16-10 = 6. The actual optimal gives difference of 1.

example_3.py — Small Values

$ Input: nums = [1,1,1,1,1,1], n = 2

› Output: 0

💡 Note: All elements are the same, so any removal gives the same result. Both groups will have sum 2, difference is 2-2 = 0.

Constraints

nums.length == 3 * n
1 ≤ n ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
The array always has exactly 3n elements

Visualization

Tap to expand

Understanding the Visualization

Analyze Left Side

For each possible split point, determine the strongest possible first team using available players

Analyze Right Side

For each possible split point, determine the strongest possible second team using available players

Find Optimal Split

Compare all possible team configurations and choose the most balanced matchup

Key Takeaway

🎯 Key Insight: Use heaps to efficiently track optimal team compositions at each split point, avoiding expensive recalculation of all possibilities.

Asked in

G Google 23 f Meta 18 a Amazon 15 ⊞ Microsoft 12

The optimal solution uses priority queues to efficiently find the best split point. We precompute the minimum possible sum for the first group (using a max-heap to track smallest elements) and maximum possible sum for the second group (using a min-heap to track largest elements). The key insight is that the split point must be in the middle n positions, and we can use heaps to avoid recalculating sums repeatedly.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(C(3n,n) * n)	O(n)	Try all possible ways to remove n elements and calculate differences
Priority Queue Optimization (Optimal)	O(n log n)	O(n)	Use heaps to efficiently find optimal split point in O(n log n) time

Brute Force (Try All Combinations) — Algorithm Steps

Generate all C(3n, n) combinations of elements to remove
For each combination, create the remaining 2n elements array
Calculate sum of first n elements and sum of second n elements
Track the minimum difference found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Generate all possible ways to choose n elements to remove from 3n elements

Test Each Combination

For each combination, remove those elements and split remainder

Calculate Difference

Compute sum_first - sum_second for current split

Track Minimum

Keep track of the smallest difference found so far

Code -

solution.c — C

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

int** combinations;
int combCount = 0;
int combCapacity = 1000;

void generateCombinations(int n, int r, int start, int* current, int currentSize) {
    if (currentSize == r) {
        if (combCount >= combCapacity) {
            combCapacity *= 2;
            combinations = realloc(combinations, combCapacity * sizeof(int*));
        }
        combinations[combCount] = malloc(r * sizeof(int));
        memcpy(combinations[combCount], current, r * sizeof(int));
        combCount++;
        return;
    }
    
    for (int i = start; i <= n - (r - currentSize); i++) {
        current[currentSize] = i;
        generateCombinations(n, r, i + 1, current, currentSize + 1);
    }
}

long long minimumDifference(int* nums, int numsSize) {
    int n = numsSize / 3;
    long long minDiff = LLONG_MAX;
    
    combinations = malloc(combCapacity * sizeof(int*));
    combCount = 0;
    
    int* current = malloc(n * sizeof(int));
    generateCombinations(3 * n, n, 0, current, 0);
    
    for (int c = 0; c < combCount; c++) {
        int* removeSet = calloc(3 * n, sizeof(int));
        for (int i = 0; i < n; i++) {
            removeSet[combinations[c][i]] = 1;
        }
        
        int* remaining = malloc(2 * n * sizeof(int));
        int remainingSize = 0;
        
        for (int i = 0; i < 3 * n; i++) {
            if (!removeSet[i]) {
                remaining[remainingSize++] = nums[i];
            }
        }
        
        long long sumFirst = 0, sumSecond = 0;
        for (int i = 0; i < n; i++) sumFirst += remaining[i];
        for (int i = n; i < 2 * n; i++) sumSecond += remaining[i];
        
        long long diff = sumFirst - sumSecond;
        if (diff < minDiff) minDiff = diff;
        
        free(removeSet);
        free(remaining);
    }
    
    for (int i = 0; i < combCount; i++) {
        free(combinations[i]);
    }
    free(combinations);
    free(current);
    
    return minDiff;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    int nums[1000];
    int count = 0;
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        nums[count++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%lld\n", minimumDifference(nums, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(3n,n) * n)

C(3n,n) combinations, each requiring O(n) time to process

✓ Linear Growth

Space Complexity

O(n)

Space for storing current combination and remaining elements

⚡ Linearithmic Space

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

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler