Maximum possible difference of sum of two subsets of an array | Set 2

• Last Updated : 25 Aug, 2021

Given an array arr[ ] consisting of N integers, the task is to find maximum difference between the sum of two subsets obtained by partitioning the array into any two non-empty subsets.
Note: The subsets cannot any common element. A subset can contain repeating elements.

Examples:

Input: arr[] = {1, 3, 2, 4, 5}
Output: 13
Explanation: The partitions {3, 2, 4, 5} and {1} maximizes the difference between the subsets.

Input: arr[] = {1, -5, 3, 2, -7}
Output: 18
Explanation: The partitions {1, 3, 2} and {-5, -7} maximizes the difference between the subsets.

Approach: This problem can be solved using greedy approach. In this problem both the subsets A and B must be non-empty. So we have to put at least one element in both of them. We try to make sum of elements in subset A as greater as possible and sum of elements in subset B as smaller as possible. Finally we print sum(A) – sum(B).

Follow the steps given below to solve the problem:

• When arr[ ] contains both non-negative and negative numbers, put all non-negative numbers in subset A and negative numbers in subset B, and print sum(A) – sum(B).
• When all numbers are positive, put all numbers in subset A except the smallest positive number put that in subset B, and print sum(A) – sum(B).
• When all numbers are negative, put all numbers in subset B except the largest negative put that in subset A, and print sum(A) – sum(B).

Below is the implementation of the above approach:

C++

 // C++ Program for the above approach #include using namespace std; int maxSumAfterPartition(int arr[], int n){    // Stores the positive elements    vector pos;     // Stores the negative elements    vector neg;     // Stores the count of 0s    int zero = 0;     // Sum of all positive numbers    int pos_sum = 0;     // Sum of all negative numbers    int neg_sum = 0;     // Iterate over the array    for (int i = 0; i < n; i++) {         if (arr[i] > 0) {             pos.push_back(arr[i]);            pos_sum += arr[i];        }        else if (arr[i] < 0) {             neg.push_back(arr[i]);            neg_sum += arr[i];        }        else {             zero++;        }    }     // Stores the difference    int ans = 0;     // Sort the positive numbers    // in ascending order    sort(pos.begin(), pos.end());     // Sort the negative numbers    // in decreasing order    sort(neg.begin(), neg.end(), greater());     // Case 1: Include both positive    // and negative numbers    if (pos.size() > 0 && neg.size() > 0) {         ans = (pos_sum - neg_sum);    }    else if (pos.size() > 0) {         if (zero > 0) {             // Case 2:  When all numbers are            // positive and array contains 0s                         //Put all numbers in subset A and              //one 0 in subset B            ans = (pos_sum);        }        else {             // Case 3: When all numbers are positive                         //Put all numbers in subset A except the               //smallest positive number which is put in B            ans = (pos_sum - 2 * pos);        }    }    else {        if (zero > 0) {             // Case 4: When all numbers are            // negative and array contains 0s             // Put all numbers in subset B            // and one 0 in subset A            ans = (-1 * neg_sum);        }        else {            // Case 5: When all numbers are negative             // Place the largest negative number            // in subset A and remaining in B            ans = (neg - (neg_sum - neg));        }    }     return ans;}int main(){    int arr[] = { 1, 2, 3, -5, -7 };    int n = sizeof(arr) / sizeof(arr);     cout << maxSumAfterPartition(arr, n);    return 0;}

Java

 /*package whatever //do not write package name here */ import java.io.*;import java.util.*;class GFG {    static int maxSumAfterPartition(int arr[], int n)    {        // Stores the positive elements       ArrayList pos            = new ArrayList();                 // Stores the negative elements         ArrayList neg            = new ArrayList();         // Stores the count of 0s        int zero = 0;         // Sum of all positive numbers        int pos_sum = 0;         // Sum of all negative numbers        int neg_sum = 0;         // Iterate over the array        for (int i = 0; i < n; i++) {             if (arr[i] > 0) {                 pos.add(arr[i]);                pos_sum += arr[i];            }            else if (arr[i] < 0) {                 neg.add(arr[i]);                neg_sum += arr[i];            }            else {                 zero++;            }        }         // Stores the difference        int ans = 0;         // Sort the positive numbers        // in ascending order        Collections.sort(pos);         // Sort the negative numbers        // in decreasing order        Collections.sort(neg);         // Case 1: Include both positive        // and negative numbers        if (pos.size() > 0 && neg.size() > 0) {             ans = (pos_sum - neg_sum);        }        else if (pos.size() > 0) {             if (zero > 0) {                 // Case 2:  When all numbers are                // positive and array contains 0s                 // Put all numbers in subset A and                // one 0 in subset B                ans = (pos_sum);            }            else {                 // Case 3: When all numbers are positive                 // Put all numbers in subset A except the                // smallest positive number which is put in                // B                ans = (pos_sum - 2 * pos.get(0));            }        }        else {            if (zero > 0) {                 // Case 4: When all numbers are                // negative and array contains 0s                 // Put all numbers in subset B                // and one 0 in subset A                ans = (-1 * neg_sum);            }            else {                // Case 5: When all numbers are negative                 // Place the largest negative number                // in subset A and remaining in B                ans = (neg.get(0) - (neg_sum - neg.get(0)));            }        }         return ans;    }   // Driver code    public static void main(String[] args)    {        int arr[] = { 1, 2, 3, -5, -7 };        int n = 5;        System.out.println(maxSumAfterPartition(arr, n));    }} // This code is contributed by maddler.

Python3

 # Python 3 Program for the above approach def maxSumAfterPartition(arr, n):    # Stores the positive elements    pos = []     # Stores the negative elements    neg = []     # Stores the count of 0s    zero = 0     # Sum of all positive numbers    pos_sum = 0     # Sum of all negative numbers    neg_sum = 0     # Iterate over the array    for i in range(n):        if (arr[i] > 0):            pos.append(arr[i])            pos_sum += arr[i]         elif(arr[i] < 0):            neg.append(arr[i])            neg_sum += arr[i]         else:            zero += 1     # Stores the difference    ans = 0     # Sort the positive numbers    # in ascending order    pos.sort()     # Sort the negative numbers    # in decreasing order    neg.sort(reverse=True)     # Case 1: Include both positive    # and negative numbers    if (len(pos) > 0 and len(neg) > 0):         ans = (pos_sum - neg_sum)    elif(len(pos) > 0):        if (zero > 0):             # Case 2:  When all numbers are            # positive and array contains 0s                         #Put all numbers in subset A and              #one 0 in subset B            ans = (pos_sum)        else:             # Case 3: When all numbers are positive                         #Put all numbers in subset A except the               #smallest positive number which is put in B            ans = (pos_sum - 2 * pos)    else:        if (zero > 0):            # Case 4: When all numbers are            # negative and array contains 0s             # Put all numbers in subset B            # and one 0 in subset A            ans = (-1 * neg_sum)        else:            # Case 5: When all numbers are negative             # Place the largest negative number            # in subset A and remaining in B            ans = (neg - (neg_sum - neg))     return ans if __name__ == '__main__':    arr = [1, 2, 3, -5, -7]    n = len(arr)    print(maxSumAfterPartition(arr, n))         # This code is contributed by ipg2016107.

C#

 // C# Program for the above approachusing System;using System.Collections.Generic; class GFG{ static int maxSumAfterPartition(int []arr, int n){    // Stores the positive elements    List pos = new List();     // Stores the negative elements    List neg = new List();     // Stores the count of 0s    int zero = 0;     // Sum of all positive numbers    int pos_sum = 0;     // Sum of all negative numbers    int neg_sum = 0;     // Iterate over the array    for (int i = 0; i < n; i++) {         if (arr[i] > 0) {             pos.Add(arr[i]);            pos_sum += arr[i];        }        else if (arr[i] < 0) {             neg.Add(arr[i]);            neg_sum += arr[i];        }        else {             zero++;        }    }     // Stores the difference    int ans = 0;     // Sort the positive numbers    // in ascending order    pos.Sort();     // Sort the negative numbers    // in decreasing order    neg.Sort();    neg.Reverse();     // Case 1: Include both positive    // and negative numbers    if (pos.Count > 0 && neg.Count > 0) {         ans = (pos_sum - neg_sum);    }    else if (pos.Count > 0) {         if (zero > 0) {             // Case 2:  When all numbers are            // positive and array contains 0s                         //Put all numbers in subset A and              //one 0 in subset B            ans = (pos_sum);        }        else {             // Case 3: When all numbers are positive                         //Put all numbers in subset A except the               //smallest positive number which is put in B            ans = (pos_sum - 2 * pos);        }    }    else {        if (zero > 0) {             // Case 4: When all numbers are            // negative and array contains 0s             // Put all numbers in subset B            // and one 0 in subset A            ans = (-1 * neg_sum);        }        else {            // Case 5: When all numbers are negative             // Place the largest negative number            // in subset A and remaining in B            ans = (neg - (neg_sum - neg));        }    }     return ans;} public static void Main(){    int []arr = { 1, 2, 3, -5, -7 };    int n = arr.Length;     Console.Write(maxSumAfterPartition(arr, n));}} // This code is contributed by ipg2016107.

Javascript


Output
18

Time Complexity: O(NlogN)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up