Fair Division Problem - Problem

You need to divide N items with integer values between two people so that the absolute difference in their total values is minimized.

Given an array values where values[i] represents the value of the i-th item, return the minimum possible absolute difference between the two groups' totals.

Example: If items have values [1, 6, 11, 5], one optimal division is {1, 5} and {6, 11}, giving totals of 6 and 17, with absolute difference |6 - 17| = 11.

Input & Output

Example 1 — Basic Case

$ Input: values = [1, 6, 11, 5]

› Output: 1

💡 Note: Optimal division: {6, 5} with sum 11 and {1, 11} with sum 12. Absolute difference = |11 - 12| = 1.

Example 2 — Perfect Split

$ Input: values = [1, 1, 3, 5]

› Output: 0

💡 Note: Perfect division: {1, 5} and {1, 3} both have sum 6. Absolute difference = |6 - 6| = 0.

Example 3 — Single Item

$ Input: values = [100]

› Output: 100

💡 Note: One person gets the item (100), the other gets nothing (0). Difference = |100 - 0| = 100.

Constraints

1 ≤ values.length ≤ 20
1 ≤ values[i] ≤ 100

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The Fair Division Problem asks us to split items between two people to minimize the absolute difference in their totals. The key insight is to use dynamic programming to find all possible subset sums, then pick the one closest to half the total. The optimal DP approach runs in O(n × sum) time and O(sum) space, much better than the O(2^n) brute force.

Common Approaches

✓ Brute Force - Try All Subsets

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

Try every possible way to divide items between two people by generating all 2^n subsets. For each subset, calculate the sum for person 1, derive person 2's sum, and track the minimum difference.

Dynamic Programming - Subset Sum

⏱️ Time: O(n × sum) Space: O(sum)

Transform the problem into finding which subset sums are achievable. Use a boolean DP array where dp[i] represents whether sum i is possible. Find the achievable sum closest to total/2.

Brute Force - Try All Subsets — Algorithm Steps

Step 1: Calculate total sum of all items
Step 2: Generate all 2^n possible subsets using bit manipulation
Step 3: For each subset, calculate sum and difference with remaining items
Step 4: Return the minimum absolute difference found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Use bit manipulation to create all 2^n subsets

Calculate Sums

For each subset, sum values and compute difference

Track Minimum

Keep track of the smallest difference found

Code -

solution.c — C

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

int solution(int* values, int n) {
    int total = 0;
    for (int i = 0; i < n; i++) total += values[i];
    
    int minDiff = INT_MAX;
    
    // Try all 2^n possible subsets
    for (int mask = 0; mask < (1 << n); mask++) {
        int subsetSum = 0;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subsetSum += values[i];
            }
        }
        
        int otherSum = total - subsetSum;
        int diff = abs(subsetSum - otherSum);
        if (diff < minDiff) minDiff = diff;
    }
    
    return minDiff;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse JSON array
    int values[1000];
    int n = 0;
    
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++;
        char* token = strtok(ptr, ",]");
        while (token) {
            values[n++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    printf("%d\n", solution(values, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We generate all 2^n possible subsets of items

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables for tracking

✓ Linear Space

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

Fair Division Problem - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Subsets — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler