Partition Array Into Two Arrays to Minimize Sum Difference

Partition Array Into Two Arrays to Minimize Sum Difference - Problem

Array Two Pointers Binary Search Dynamic Programming Bit Manipulation Ordered Set Bitmask Hard

You're given an integer array nums of 2n integers. Your task is to partition this array into two separate arrays, each containing exactly n elements, such that the absolute difference between the sums of these two arrays is minimized.

Think of it as trying to balance two scales as evenly as possible - you want to distribute the weights (numbers) so that neither side is much heavier than the other.

Goal: Find the minimum possible absolute difference between the sums of the two partitioned arrays.

Example: If nums = [3,9,7,3], you could partition it as [3,7] and [9,3], giving sums of 10 and 12 respectively, for a difference of 2.

Input & Output

example_1.py — Basic Case

$ Input: [3,9,7,3]

› Output: 2

💡 Note: We can partition into [3,7] and [9,3]. The sums are 10 and 12 respectively, giving an absolute difference of 2.

example_2.py — Larger Array

$ Input: [-36,36]

› Output: 72

💡 Note: We must partition into [-36] and [36]. The sums are -36 and 36 respectively, giving an absolute difference of 72.

example_3.py — All Same Elements

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

› Output: 0

💡 Note: We can partition into [2,2] and [2,2]. Both sums are 4, giving an absolute difference of 0.

Visualization

Tap to expand

ⁿ)Meet-in-Middle: O(3ⁿ)Space: O(2ⁿ)Much faster for large n!

Understanding the Visualization

Items to Balance

You have 2n items with different weights that need to be distributed evenly

Split Strategy

Instead of trying all combinations, divide items into two groups and analyze each separately

Smart Matching

Use binary search to efficiently find the best way to combine subsets from both groups

Optimal Balance

Find the combination that minimizes the absolute weight difference between the two scales

Key Takeaway

🎯 Key Insight: Meet-in-the-middle reduces exponential complexity by splitting the problem space and using binary search for efficient matching, making it practical for larger inputs than brute force approaches.

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

We generate 2^n subsets for each half, then for each subset in left half, we binary search in right half

✓ Linear Growth

Space Complexity

O(2^n)

We store all possible subset sums for both halves

⚠ Quadratic Space

Constraints

2 ≤ nums.length ≤ 20
nums.length is even
-10⁶ ≤ nums[i] ≤ 10⁶
The array contains exactly 2n elements

Asked in

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

This problem requires finding the minimum difference between two equal-sized partitions of an array. The optimal approach uses the meet-in-the-middle technique with binary search, reducing the time complexity from O(4ⁿ) to O(3ⁿ). We split the array into two halves, generate all possible subset sums for each half, then efficiently match subsets from both halves to form valid partitions of size n each.

Common Approaches

Approach	Time	Space	Notes
✓ Meet in the Middle with Binary Search	O(3^n)	O(2^n)	Split array in half, generate all subset sums for each half, then use binary search to find optimal combinations
Brute Force (Generate All Combinations)	O(C(2n,n)) = O(4^n / √n)	O(n)	Generate all possible ways to choose n elements and check each partition

Meet in the Middle with Binary Search — Algorithm Steps

Split the 2n elements into two groups: left half and right half (n elements each)
For each half, generate all possible subset sums along with subset sizes using bit manipulation
Group the subset sums by their sizes for efficient lookup
For each possible size k in left half, we need size (n-k) in right half to get total n elements
Use binary search to find the closest sum in the right half that minimizes the total difference
Track the minimum difference found across all valid combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Split array

Divide 2n elements into two groups of n each

Generate subset sums

For each group, generate all possible subset sums with their sizes

Binary search matching

For each subset from left, binary search for optimal subset from right

Find minimum

Track the minimum difference across all valid combinations

Code -

solution.c — C

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

typedef struct {
    long long sum;
    int size;
} SumInfo;

int compare(const void* a, const void* b) {
    long long diff = ((SumInfo*)a)->sum - ((SumInfo*)b)->sum;
    return diff > 0 ? 1 : (diff < 0 ? -1 : 0);
}

int binarySearch(SumInfo* arr, int size, long long target) {
    int left = 0, right = size;
    while (left < right) {
        int mid = (left + right) / 2;
        if (arr[mid].sum < target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

int minimumDifference(int* nums, int numsSize) {
    int n = numsSize / 2;
    long long totalSum = 0;
    for (int i = 0; i < numsSize; i++) {
        totalSum += nums[i];
    }
    
    // Generate all subset sums for left half
    SumInfo leftSums[1 << 10];
    int leftCount = 0;
    
    for (int mask = 0; mask < (1 << n); mask++) {
        long long sum = 0;
        int count = 0;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                sum += nums[i];
                count++;
            }
        }
        leftSums[leftCount].sum = sum;
        leftSums[leftCount].size = count;
        leftCount++;
    }
    
    // Generate all subset sums for right half
    SumInfo rightSums[1 << 10];
    int rightCount = 0;
    
    for (int mask = 0; mask < (1 << n); mask++) {
        long long sum = 0;
        int count = 0;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                sum += nums[n + i];
                count++;
            }
        }
        rightSums[rightCount].sum = sum;
        rightSums[rightCount].size = count;
        rightCount++;
    }
    
    // Sort right sums for binary search
    qsort(rightSums, rightCount, sizeof(SumInfo), compare);
    
    long long minDiff = LLONG_MAX;
    
    for (int i = 0; i < leftCount; i++) {
        int needSize = n - leftSums[i].size;
        long long leftSum = leftSums[i].sum;
        
        for (int j = 0; j < rightCount; j++) {
            if (rightSums[j].size == needSize) {
                long long sum1 = leftSum + rightSums[j].sum;
                long long sum2 = totalSum - sum1;
                long long diff = llabs(sum1 - sum2);
                if (diff < minDiff) {
                    minDiff = diff;
                }
            }
        }
    }
    
    return (int) minDiff;
}

int main() {
    int nums[20];
    int count = 0;
    char c;
    int num = 0;
    int sign = 1;
    int reading = 0;
    
    while ((c = getchar()) != EOF && c != '\n') {
        if (c >= '0' && c <= '9') {
            reading = 1;
            num = num * 10 + (c - '0');
        } else if (c == '-') {
            sign = -1;
        } else if (reading) {
            nums[count++] = sign * num;
            num = 0;
            sign = 1;
            reading = 0;
        }
    }
    if (reading) {
        nums[count++] = sign * num;
    }
    
    printf("%d\n", minimumDifference(nums, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

We generate 2^n subsets for each half, then for each subset in left half, we binary search in right half

✓ Linear Growth

Space Complexity

O(2^n)

We store all possible subset sums for both halves

⚠ Quadratic Space

Constraints

2 ≤ nums.length ≤ 20
nums.length is even
-10⁶ ≤ nums[i] ≤ 10⁶
The array contains exactly 2n elements

38.0K Views

Medium Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Meet in the Middle with Binary Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler