# 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<``int``> pos;`   `    ``// Stores the negative elements` `    ``vector<``int``> 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<``int``>());`   `    ``// 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[``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[``0``] ``-` `(neg_sum ``-` `neg[``0``]))`   `    ``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 approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{`   `static` `int` `maxSumAfterPartition(``int` `[]arr, ``int` `n)` `{` `    ``// Stores the positive elements` `    ``List<``int``> pos = ``new` `List<``int``>();`   `    ``// Stores the negative elements` `    ``List<``int``> neg = ``new` `List<``int``>();`   `    ``// 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
Recommended Articles
Page :