Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Partition a set into two non-empty subsets such that the difference of subset sums is maximum

  • Difficulty Level : Medium
  • Last Updated : 21 Apr, 2021

Given a set of integers S, the task is to divide the given set into two non-empty sets S1 and S2 such that the absolute difference between their sums is maximum, i.e., abs(sum(S1) – sum(S2)) is maximum.

Example:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: S[] = { 1, 2, 1 } 
Output: 2
Explanation:
The subsets are {1} and {2, 1}. Their absolute difference is 
abs(1 – (2+1)) = 2, which is maximum. 



Input: S[] = { -2, 3, -1, 5 }
Output: 11
Explanation:
The subsets are {-1, -2} and {3, 5}. Their absolute difference is 
abs((-1, -2) – (3+5)) = 11, which is maximum. 

 

Naive Approach: Generate and store all the subsets of the set of integers and find the maximum absolute difference between the sum of the subset and the difference between the total sum of the set and the sum of that subset, i.e, abs(sum(S1) – (totalSum – sum(S1)).
Time Complexity: O(2N)
Auxiliary Space: O(2N)

Efficient Approach: To optimize the naive approach, the idea is to use some mathematical observations. The problem can be divided into two cases:

  • If the set contains only positive integers or only negative integers, then the maximum difference is obtained by splitting the set such that one subset contains only the minimum element of the set and the other subset contains all the remaining elements of the set, i.e.,

 
 

abs((totalSum – min(S)) – min(S)) or abs(totalSum – 2×min(S)), where S is the set of integers

 

  • If the set contains both positive and negative integers, then the maximum difference is obtained by splitting the set such that one subset contains all the positive integers and the other subset contains all the negative integers, i.e.,

 
 

abs(sum(S1) – sum(S2)) or abs(sum(S)), where S1, S2 is the set of positive and negative integers respectively.

 

Below is the implementation of the above approach:

C++




// C++ Program for above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the maximum
// difference between the subset sums
int maxDiffSubsets(int arr[], int N)
{
    // Stores the total
    // sum of the array
    int totalSum = 0;
 
    // Checks for positive
    // and negative elements
    bool pos = false, neg = false;
 
    // Stores the minimum element
    // from the given array
    int min = INT_MAX;
 
    // Traverse the array
    for (int i = 0; i < N; i++)
    {
        // Calculate total sum
        totalSum += abs(arr[i]);
 
        // Mark positive element
        // present in the set
        if (arr[i] > 0)
            pos = true;
 
        // Mark negative element
        // present in the set
        if (arr[i] < 0)
            neg = true;
 
        // Find the minimum
        // element of the set
        if (arr[i] < min)
            min = arr[i];
    }
 
    // If the array contains both
    // positive and negative elements
    if (pos && neg)
        return totalSum;
 
    // Otherwise
    else
        return totalSum - 2 * min;
}
 
// Driver Code
int main()
{
    // Given the array
    int S[] = {1, 2, 1};
 
    // Length of the array
    int N = sizeof(S) / sizeof(S[0]);
 
    if (N < 2)
        cout << ("Not Possible");
 
    else
        // Function Call
        cout << (maxDiffSubsets(S, N));
}
 
// This code is contributed by Chitranayal
Java



// Java Program for above approach
 
import java.util.*;
import java.lang.*;
 
class GFG {
 
    // Function to return the maximum
    // difference between the subset sums
    static int maxDiffSubsets(int[] arr)
    {
        // Stores the total
        // sum of the array
        int totalSum = 0;
 
        // Checks for positive
        // and negative elements
        boolean pos = false, neg = false;
 
        // Stores the minimum element
        // from the given array
        int min = Integer.MAX_VALUE;
 
        // Traverse the array
        for (int i = 0; i < arr.length; i++) {
 
            // Calculate total sum
            totalSum += Math.abs(arr[i]);
 
            // Mark positive element
            // present in the set
            if (arr[i] > 0)
                pos = true;
 
            // Mark negative element
            // present in the set
            if (arr[i] < 0)
                neg = true;
 
            // Find the minimum
            // element of the set
            if (arr[i] < min)
                min = arr[i];
        }
 
        // If the array contains both
        // positive and negative elements
        if (pos && neg)
            return totalSum;
 
        // Otherwise
        else
            return totalSum - 2 * min;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        // Given the array
        int[] S = { 1, 2, 1 };
 
        // Length of the array
        int N = S.length;
 
        if (N < 2)
            System.out.println("Not Possible");
 
        else
            // Function Call
            System.out.println(maxDiffSubsets(S));
    }
}
Python3



# Python3 program for above approach
import sys
 
# Function to return the maximum
# difference between the subset sums
def maxDiffSubsets(arr):
     
    # Stores the total
    # sum of the array
    totalSum = 0
 
    # Checks for positive
    # and negative elements
    pos = False
    neg = False
 
    # Stores the minimum element
    # from the given array
    min = sys.maxsize
 
    # Traverse the array
    for i in range(len(arr)):
 
        # Calculate total sum
        totalSum += abs(arr[i])
 
        # Mark positive element
        # present in the set
        if (arr[i] > 0):
            pos = True
 
        # Mark negative element
        # present in the set
        if (arr[i] < 0):
            neg = True
 
        # Find the minimum
        # element of the set
        if (arr[i] < min):
            min = arr[i]
 
    # If the array contains both
    # positive and negative elements
    if (pos and neg):
        return totalSum
 
    # Otherwise
    else:
        return totalSum - 2 * min
 
# Driver Code
if __name__ == '__main__':
     
    # Given the array
    S = [ 1, 2, 1 ]
 
    # Length of the array
    N = len(S)
 
    if (N < 2):
        print("Not Possible")
    else:
         
        # Function Call
        print(maxDiffSubsets(S))
         
# This code is contributed by mohit kumar 29
C#



// C# Program for above approach
using System;
class GFG{
 
    // Function to return the maximum
    // difference between the subset sums
    static int maxDiffSubsets(int[] arr)
    {
        // Stores the total
        // sum of the array
        int totalSum = 0;
 
        // Checks for positive
        // and negative elements
        bool pos = false, neg = false;
 
        // Stores the minimum element
        // from the given array
        int min = int.MaxValue;
 
        // Traverse the array
        for (int i = 0; i < arr.Length; i++)
        {
            // Calculate total sum
            totalSum += Math.Abs(arr[i]);
 
            // Mark positive element
            // present in the set
            if (arr[i] > 0)
                pos = true;
 
            // Mark negative element
            // present in the set
            if (arr[i] < 0)
                neg = true;
 
            // Find the minimum
            // element of the set
            if (arr[i] < min)
                min = arr[i];
        }
 
        // If the array contains both
        // positive and negative elements
        if (pos && neg)
            return totalSum;
 
        // Otherwise
        else
            return totalSum - 2 * min;
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        // Given the array
        int[] S = {1, 2, 1};
 
        // Length of the array
        int N = S.Length;
 
        if (N < 2)
            Console.WriteLine("Not Possible");
        else
           
            // Function Call
            Console.WriteLine(maxDiffSubsets(S));
    }
}
 
// This code is contributed by Rajput-Ji
Javascript



<script>
// javascript Program for above approach
    // Function to return the maximum
    // difference between the subset sums
    function maxDiffSubsets(arr) {
        // Stores the total
        // sum of the array
        var totalSum = 0;
 
        // Checks for positive
        // and negative elements
        var pos = false, neg = false;
 
        // Stores the minimum element
        // from the given array
        var min = Number.MAX_VALUE;
 
        // Traverse the array
        for (i = 0; i < arr.length; i++) {
 
            // Calculate total sum
            totalSum += Math.abs(arr[i]);
 
            // Mark positive element
            // present in the set
            if (arr[i] > 0)
                pos = true;
 
            // Mark negative element
            // present in the set
            if (arr[i] < 0)
                neg = true;
 
            // Find the minimum
            // element of the set
            if (arr[i] < min)
                min = arr[i];
        }
 
        // If the array contains both
        // positive and negative elements
        if (pos && neg)
            return totalSum;
 
        // Otherwise
        else
            return totalSum - 2 * min;
    }
 
    // Driver Code
     
        // Given the array
        var S = [ 1, 2, 1 ];
 
        // Length of the array
        var N = S.length;
 
        if (N < 2)
            document.write("Not Possible");
 
        else
            // Function Call
            document.write(maxDiffSubsets(S));
 
// This code is contributed by todaysgaurav
</script>
Output: 
2
Time Complexity: O(N)
Auxiliary Space: O(1)



My Personal Notes
arrow_drop_up
Previous
Rearrange and update array elements as specified by the given queries
Next

Partition a set into two subsets such that the difference of subset sums is minimum
Recommended Articles
Page :
Partition an array of non-negative integers into two subsets such that average of both the subsets is equal
11, Jul 19
Partition into two subarrays of lengths k and (N - k) such that the difference of sums is maximum
15, Dec 17
Partition a set into two subsets such that difference between max of one and min of other is minimized
16, Jun 20
Partition array into two subsets with minimum Bitwise XOR between their maximum and minimum
20, Jan 21
Split Array into K non-overlapping subset such that maximum among all subset sum is minimum
20, Jul 21
Split array into two equal length subsets such that all repetitions of a number lies in a single subset
28, Sep 20
Maximum number of subsets an array can be split into such that product of their minimums with size of subsets is at least K
21, Apr 21
Smallest subset of maximum sum possible by splitting array into two subsets
21, Apr 21
Closest sum partition (into two subsets) of numbers from 1 to n
24, Jan 19
Partition an array into two subsets with equal count of unique elements
29, Jun 21
Partition of a set into K subsets with equal sum using BitMask and DP
12, Jun 20
Divide array in two Subsets such that sum of square of sum of both subsets is maximum
07, Feb 20
Minimize cost to split an array into K subsets such that the cost of each element is its product with its position in the subset
03, Jan 21
Split array into minimum number of subsets such that elements of all pairs are present in different subsets at least once
04, Jan 21
Find maximum subset sum formed by partitioning any subset of array into 2 partitions with equal sum
08, Apr 20
Split array into equal length subsets with maximum sum of Kth largest element of each subset
02, Dec 20
Partition a Linked List into 3 parts such that the maximum difference between their sizes is minimum
23, Jul 21
Partition array into minimum number of equal length subsets consisting of a single distinct value
23, Nov 20
Maximum size of subset such that product of all subset elements is a factor of N
27, Sep 21
Partition an array such into maximum increasing segments
18, Nov 18
Partition first N natural number into two sets such that their sum is not coprime
28, Jun 19
Split N powers of 2 into two subsets such that their difference of sum is minimum
07, May 20
Split array into minimum number of subsets with every element of a subset divisible by its minimum
12, Feb 21
Split array into K-length subsets to minimize sum of second smallest element of each subset
25, Dec 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
offbeat
@offbeat
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!