Given a set of integers, the task is to divide it into two sets S1 and S2 such that the absolute difference between their sums is minimum.

If there is a set S with n elements, then if we assume Subset1 has m elements, Subset2 must have n-m elements and the value of abs(sum(Subset1) – sum(Subset2)) should be minimum.

Example:

Input: arr[] = {1, 6, 11, 5} Output: 1 Explanation: Subset1 = {1, 5, 6}, sum of Subset1 = 12 Subset2 = {11}, sum of Subset2 = 11

This problem is mainly an extension to the Dynamic Programming| Set 18 (Partition Problem).

**Recursive Solution**

The recursive approach is to generate all possible sums from all the values of array and to check which solution is the most optimal one.

To generate sums we either include the i’th item in set 1 or don’t include, i.e., include in set 2.

## C

`// A Recursive C program to solve minimum sum partition ` `// problem. ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function to find the minimum sum ` `int` `findMinRec(` `int` `arr[], ` `int` `i, ` `int` `sumCalculated, ` `int` `sumTotal) ` `{ ` ` ` `// If we have reached last element. Sum of one ` ` ` `// subset is sumCalculated, sum of other subset is ` ` ` `// sumTotal-sumCalculated. Return absolute difference ` ` ` `// of two sums. ` ` ` `if` `(i==0) ` ` ` `return` `abs` `((sumTotal-sumCalculated) - sumCalculated); ` ` ` ` ` ` ` `// For every item arr[i], we have two choices ` ` ` `// (1) We do not include it first set ` ` ` `// (2) We include it in first set ` ` ` `// We return minimum of two choices ` ` ` `return` `min(findMinRec(arr, i-1, sumCalculated+arr[i-1], sumTotal), ` ` ` `findMinRec(arr, i-1, sumCalculated, sumTotal)); ` `} ` ` ` `// Returns minimum possible difference between sums ` `// of two subsets ` `int` `findMin(` `int` `arr[], ` `int` `n) ` `{ ` ` ` `// Compute total sum of elements ` ` ` `int` `sumTotal = 0; ` ` ` `for` `(` `int` `i=0; i<n; i++) ` ` ` `sumTotal += arr[i]; ` ` ` ` ` `// Compute result using recursive function ` ` ` `return` `findMinRec(arr, n, 0, sumTotal); ` `} ` ` ` `// Driver program to test above function ` `int` `main() ` `{ ` ` ` `int` `arr[] = {3, 1, 4, 2, 2, 1}; ` ` ` `int` `n = ` `sizeof` `(arr)/` `sizeof` `(arr[0]); ` ` ` `cout << ` `"The minimum difference between two sets is "` ` ` `<< findMin(arr, n); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// JAVA code to partition a set into two subsets ` `// such that the difference of subset sums ` `// is minimum ` `import` `java.util.*; ` ` ` `class` `GFG { ` ` ` ` ` `// Function to find the minimum sum ` ` ` `public` `static` `int` `findMinRec(` `int` `arr[], ` `int` `i, ` ` ` `int` `sumCalculated, ` ` ` `int` `sumTotal) ` ` ` `{ ` ` ` `// If we have reached last element. ` ` ` `// Sum of one subset is sumCalculated, ` ` ` `// sum of other subset is sumTotal- ` ` ` `// sumCalculated. Return absolute ` ` ` `// difference of two sums. ` ` ` `if` `(i == ` `0` `) ` ` ` `return` `Math.abs((sumTotal-sumCalculated) - ` ` ` `sumCalculated); ` ` ` ` ` ` ` `// For every item arr[i], we have two choices ` ` ` `// (1) We do not include it first set ` ` ` `// (2) We include it in first set ` ` ` `// We return minimum of two choices ` ` ` `return` `Math.min(findMinRec(arr, i - ` `1` `, sumCalculated ` ` ` `+ arr[i-` `1` `], sumTotal), ` ` ` `findMinRec(arr, i-` `1` `, ` ` ` `sumCalculated, sumTotal)); ` ` ` `} ` ` ` ` ` `// Returns minimum possible difference between ` ` ` `// sums of two subsets ` ` ` `public` `static` `int` `findMin(` `int` `arr[], ` `int` `n) ` ` ` `{ ` ` ` `// Compute total sum of elements ` ` ` `int` `sumTotal = ` `0` `; ` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++) ` ` ` `sumTotal += arr[i]; ` ` ` ` ` `// Compute result using recursive function ` ` ` `return` `findMinRec(arr, n, ` `0` `, sumTotal); ` ` ` `} ` ` ` ` ` `/* Driver program to test above function */` ` ` `public` `static` `void` `main(String[] args) ` ` ` `{ ` ` ` `int` `arr[] = {` `3` `, ` `1` `, ` `4` `, ` `2` `, ` `2` `, ` `1` `}; ` ` ` `int` `n = arr.length; ` ` ` `System.out.print(` `"The minimum difference"` `+ ` ` ` `" between two sets is "` `+ ` ` ` `findMin(arr, n)); ` ` ` `} ` `} ` ` ` `// This code is contributed by Arnav Kr. Mandal. ` |

*chevron_right*

*filter_none*

## C#

`// C# code to partition a set into two subsets ` `// such that the difference of subset sums ` `// is minimum ` `using` `System; ` ` ` `class` `GFG { ` ` ` ` ` `// Function to find the minimum sum ` ` ` `public` `static` `int` `findMinRec(` `int` `[]arr, ` `int` `i, ` ` ` `int` `sumCalculated, ` ` ` `int` `sumTotal) ` ` ` `{ ` ` ` `// If we have reached last element. ` ` ` `// Sum of one subset is sumCalculated, ` ` ` `// sum of other subset is sumTotal- ` ` ` `// sumCalculated. Return absolute ` ` ` `// difference of two sums. ` ` ` `if` `(i == 0) ` ` ` `return` `Math.Abs((sumTotal-sumCalculated) ` ` ` `- sumCalculated); ` ` ` ` ` ` ` `// For every item arr[i], we have two choices ` ` ` `// (1) We do not include it first set ` ` ` `// (2) We include it in first set ` ` ` `// We return minimum of two choices ` ` ` `return` `Math.Min(findMinRec(arr, i - 1, ` ` ` `sumCalculated + arr[i-1], sumTotal), ` ` ` `findMinRec(arr, i-1, sumCalculated, ` ` ` `sumTotal)); ` ` ` `} ` ` ` ` ` `// Returns minimum possible difference between ` ` ` `// sums of two subsets ` ` ` `public` `static` `int` `findMin(` `int` `[]arr, ` `int` `n) ` ` ` `{ ` ` ` ` ` `// Compute total sum of elements ` ` ` `int` `sumTotal = 0; ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `sumTotal += arr[i]; ` ` ` ` ` `// Compute result using recursive function ` ` ` `return` `findMinRec(arr, n, 0, sumTotal); ` ` ` `} ` ` ` ` ` `/* Driver program to test above function */` ` ` `public` `static` `void` `Main() ` ` ` `{ ` ` ` `int` `[]arr = {3, 1, 4, 2, 2, 1}; ` ` ` `int` `n = arr.Length; ` ` ` `Console.Write(` `"The minimum difference"` `+ ` ` ` `" between two sets is "` `+ ` ` ` `findMin(arr, n)); ` ` ` `} ` `} ` ` ` `// This code is contributed by nitin mittal. ` |

*chevron_right*

*filter_none*

**Output:**

The minimum difference between two sets is 1

**Time Complexity:**

All the sums can be generated by either (1) including that element in set 1. (2) without including that element in set 1. So possible combinations are :- arr[0] (1 or 2) -> 2 values arr[1] (1 or 2) -> 2 values . . . arr[n] (2 or 2) -> 2 values So time complexity will be 2*2*..... *2 (For n times), that is O(2^n).

**Dynamic Programming**

The problem can be solved using dynamic programming when the sum of the elements is not too big. We can create a 2D array dp[n+1][sum+1] where n is number of elements in given set and sum is sum of all elements. We can construct the solution in bottom up manner.

The task is to divide the set into two parts. We will consider the following factors for dividing it. Let dp[n+1][sum+1] = {1 if some subset from 1st to i'th has a sum equal to j 0 otherwise} i ranges from {1..n} j ranges from {0..(sum of all elements)} So dp[n+1][sum+1] will be 1 if 1) The sum j is achieved including i'th item 2) The sum j is achieved excluding i'th item. Let sum of all the elements be S. To find Minimum sum difference, w have to find j such that Min{sum - j*2 : dp[n][j] == 1 } where j varies from 0 to sum/2 The idea is, sum of S1 is j and it should be closest to sum/2, i.e., 2*j should be closest to sum.

Below is the implementation of above code.

## C++

`// A Recursive C program to solve minimum sum partition ` `// problem. ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Returns the minimum value of the difference of the two sets. ` `int` `findMin(` `int` `arr[], ` `int` `n) ` `{ ` ` ` `// Calculate sum of all elements ` ` ` `int` `sum = 0; ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `sum += arr[i]; ` ` ` ` ` `// Create an array to store results of subproblems ` ` ` `bool` `dp[n+1][sum+1]; ` ` ` ` ` `// Initialize first column as true. 0 sum is possible ` ` ` `// with all elements. ` ` ` `for` `(` `int` `i = 0; i <= n; i++) ` ` ` `dp[i][0] = ` `true` `; ` ` ` ` ` `// Initialize top row, except dp[0][0], as false. With ` ` ` `// 0 elements, no other sum except 0 is possible ` ` ` `for` `(` `int` `i = 1; i <= sum; i++) ` ` ` `dp[0][i] = ` `false` `; ` ` ` ` ` `// Fill the partition table in bottom up manner ` ` ` `for` `(` `int` `i=1; i<=n; i++) ` ` ` `{ ` ` ` `for` `(` `int` `j=1; j<=sum; j++) ` ` ` `{ ` ` ` `// If i'th element is excluded ` ` ` `dp[i][j] = dp[i-1][j]; ` ` ` ` ` `// If i'th element is included ` ` ` `if` `(arr[i-1] <= j) ` ` ` `dp[i][j] |= dp[i-1][j-arr[i-1]]; ` ` ` `} ` ` ` `} ` ` ` ` ` `// Initialize difference of two sums. ` ` ` `int` `diff = INT_MAX; ` ` ` ` ` `// Find the largest j such that dp[n][j] ` ` ` `// is true where j loops from sum/2 t0 0 ` ` ` `for` `(` `int` `j=sum/2; j>=0; j--) ` ` ` `{ ` ` ` `// Find the ` ` ` `if` `(dp[n][j] == ` `true` `) ` ` ` `{ ` ` ` `diff = sum-2*j; ` ` ` `break` `; ` ` ` `} ` ` ` `} ` ` ` `return` `diff; ` `} ` ` ` `// Driver program to test above function ` `int` `main() ` `{ ` ` ` `int` `arr[] = {3, 1, 4, 2, 2, 1}; ` ` ` `int` `n = ` `sizeof` `(arr)/` `sizeof` `(arr[0]); ` ` ` `cout << ` `"The minimum difference between 2 sets is "` ` ` `<< findMin(arr, n); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// A Recursive java program to solve ` `// minimum sum partition problem. ` `import` `java.io.*; ` ` ` `class` `GFG ` `{ ` ` ` `// Returns the minimum value of ` ` ` `//the difference of the two sets. ` ` ` `static` `int` `findMin(` `int` `arr[], ` `int` `n) ` ` ` `{ ` ` ` `// Calculate sum of all elements ` ` ` `int` `sum = ` `0` `; ` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++) ` ` ` `sum += arr[i]; ` ` ` ` ` `// Create an array to store ` ` ` `// results of subproblems ` ` ` `boolean` `dp[][] = ` `new` `boolean` `[n + ` `1` `][sum + ` `1` `]; ` ` ` ` ` `// Initialize first column as true. ` ` ` `// 0 sum is possible with all elements. ` ` ` `for` `(` `int` `i = ` `0` `; i <= n; i++) ` ` ` `dp[i][` `0` `] = ` `true` `; ` ` ` ` ` `// Initialize top row, except dp[0][0], ` ` ` `// as false. With 0 elements, no other ` ` ` `// sum except 0 is possible ` ` ` `for` `(` `int` `i = ` `1` `; i <= sum; i++) ` ` ` `dp[` `0` `][i] = ` `false` `; ` ` ` ` ` `// Fill the partition table ` ` ` `// in bottom up manner ` ` ` `for` `(` `int` `i = ` `1` `; i <= n; i++) ` ` ` `{ ` ` ` `for` `(` `int` `j = ` `1` `; j <= sum; j++) ` ` ` `{ ` ` ` `// If i'th element is excluded ` ` ` `dp[i][j] = dp[i - ` `1` `][j]; ` ` ` ` ` `// If i'th element is included ` ` ` `if` `(arr[i - ` `1` `] <= j) ` ` ` `dp[i][j] |= dp[i - ` `1` `][j - arr[i - ` `1` `]]; ` ` ` `} ` ` ` `} ` ` ` ` ` `// Initialize difference of two sums. ` ` ` `int` `diff = Integer.MAX_VALUE; ` ` ` ` ` `// Find the largest j such that dp[n][j] ` ` ` `// is true where j loops from sum/2 t0 0 ` ` ` `for` `(` `int` `j = sum / ` `2` `; j >= ` `0` `; j--) ` ` ` `{ ` ` ` `// Find the ` ` ` `if` `(dp[n][j] == ` `true` `) ` ` ` `{ ` ` ` `diff = sum - ` `2` `* j; ` ` ` `break` `; ` ` ` `} ` ` ` `} ` ` ` `return` `diff; ` ` ` `} ` ` ` ` ` `// Driver program ` ` ` `public` `static` `void` `main (String[] args) ` ` ` `{ ` ` ` `int` `arr[] = {` `3` `, ` `1` `, ` `4` `, ` `2` `, ` `2` `, ` `1` `}; ` ` ` `int` `n = arr.length; ` ` ` `System.out.println (` `"The minimum difference between 2 sets is "` ` ` `+ findMin(arr, n)); ` ` ` ` ` `} ` `} ` `// This code is contributed by vt_m ` |

*chevron_right*

*filter_none*

## Python3

`# A Recursive Python3 program to solve ` `# minimum sum partition problem. ` `import` `sys ` ` ` `# Returns the minimum value of the ` `# difference of the two sets. ` `def` `findMin(a, n): ` ` ` ` ` `su ` `=` `0` ` ` ` ` `# Calculate sum of all elements ` ` ` `su ` `=` `sum` `(a) ` ` ` ` ` `# Create an 2d list to store ` ` ` `# results of subproblems ` ` ` `dp ` `=` `[[` `0` `for` `i ` `in` `range` `(su ` `+` `1` `)] ` ` ` `for` `j ` `in` `range` `(n ` `+` `1` `)] ` ` ` ` ` `# Initialize first column as true. ` ` ` `# 0 sum is possible ` ` ` `# with all elements. ` ` ` `for` `i ` `in` `range` `(n ` `+` `1` `): ` ` ` `dp[i][` `0` `] ` `=` `True` ` ` ` ` `# Initialize top row, except dp[0][0], ` ` ` `# as false. With 0 elements, no other ` ` ` `# sum except 0 is possible ` ` ` `for` `j ` `in` `range` `(` `1` `, su ` `+` `1` `): ` ` ` `dp[` `0` `][j] ` `=` `False` ` ` ` ` `# Fill the partition table in ` ` ` `# bottom up manner ` ` ` `for` `i ` `in` `range` `(` `1` `, n ` `+` `1` `): ` ` ` `for` `j ` `in` `range` `(` `1` `, su ` `+` `1` `): ` ` ` ` ` `# If i'th element is excluded ` ` ` `dp[i][j] ` `=` `dp[i ` `-` `1` `][j] ` ` ` ` ` `# If i'th element is included ` ` ` `if` `a[i ` `-` `1` `] <` `=` `j: ` ` ` `dp[i][j] |` `=` `dp[i ` `-` `1` `][j ` `-` `a[i ` `-` `1` `]] ` ` ` ` ` `# Initialize difference ` ` ` `# of two sums. ` ` ` `diff ` `=` `sys.maxsize ` ` ` ` ` `# Find the largest j such that dp[n][j] ` ` ` `# is true where j loops from sum/2 t0 0 ` ` ` `for` `j ` `in` `range` `(su ` `/` `/` `2` `, ` `-` `1` `, ` `-` `1` `): ` ` ` `if` `dp[n][j] ` `=` `=` `True` `: ` ` ` `diff ` `=` `su ` `-` `(` `2` `*` `j) ` ` ` `break` ` ` ` ` `return` `diff ` ` ` `# Driver code ` `a ` `=` `[ ` `3` `, ` `1` `, ` `4` `, ` `2` `, ` `2` `, ` `1` `] ` `n ` `=` `len` `(a) ` ` ` `print` `(` `"The minimum difference between "` ` ` `"2 sets is "` `, findMin(a, n)) ` ` ` `# This code is contributed by Tokir Manva ` |

*chevron_right*

*filter_none*

**Output:**

The minimum difference between 2 sets is 1

Time Complexity = O(n*sum) where n is the number of elements and sum is sum of all elements.

Note that the above solution is in Pseudo Polynomial Time (time complexity is dependent on the numeric value of input).

This article is contributed by **Abhiraj Smit**. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

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.

## Recommended Posts:

- Partition an array of non-negative integers into two subsets such that average of both the subsets is equal
- Count number of ways to partition a set into k subsets
- Partition of a set into K subsets with equal sum using BitMask and DP
- Find maximum subset sum formed by partitioning any subset of array into 2 partitions with equal sum
- Find all distinct subset (or subsequence) sums of an array | Set-2
- Find all distinct subset (or subsequence) sums of an array
- Partitioning into two contiguous element subarrays with equal sums
- Number of ways to partition a string into two balanced subsequences
- Maximum subset sum such that no two elements in set have same digit in them
- Count number of subsets whose median is also present in the same subset
- Partition the array in K segments such that bitwise AND of individual segment sum is maximized
- Count ways to partition a string such that both parts have equal distinct characters
- Split a binary string into K subsets minimizing sum of products of occurrences of 0 and 1
- Minimum count of elements that sums to a given number
- Generate a combination of minimum coins that sums to a given value
- Minimum cost to partition the given binary string
- Difference between sums of odd level and even level nodes of a Binary Tree
- Largest subset of rectangles such that no rectangle fit in any other rectangle
- Find the length of the Largest subset such that all elements are Pairwise Coprime
- Split the string into minimum parts such that each part is in the another string