Given a set of integers, partition those integers into two parts where the difference between the two parts is minimum. This problem is known as **balanced partition problem.** For example,

Mathematically, you have a set of n integers each in the range 0, . . . , K. Partition these integers into two subsets such that you minimize |S1 − S2|, where S1 and S2 denote the sums of the elements in each of the two subsets.Input:A = [1,7,4,11],Output:1Explanation:Two subsets can be: {1,11} and {7,4}, two have a difference of 1, which is the minimum difference we can get by splitting this array.

Balance partition problem can be asked in many other ways, for instance, given a list of 22 players and their strengths, divide those 22 players into two teams so that both teams are balanced. Another version can be that you have

No matter what version is asked, the approach remains the same.

## Balance partition problem: thoughts

The brute force method will be to list down all the subsets of the given set and find the sum of each one of them. Then scan through the sum of all the subsets and find the two closest ones. For a set of `n` elements, there can be `2`

subset. Therefore, the complexity of this brute force solution is already exponential.^{n}

Let me tweak balance partition problem a bit. We find if there are two subsets of the set of integers such that the difference between `sum` of these two subsets is zero. Essentially, this is a special case of the original problem. If the difference between the sum of two subsets is zero that means the sum of both subsets should be exactly equal to half of the sum of all elements in the set.

So problem reduces to a smaller problem that is to find if there is a subset of integers which add up to half the sum of all integers in the set? This is the subset sum problem which we have already solved.

How can we use information provided by subset set problem above? Let’s say `S` is the sum of all the integers in the set. `S/2` will be half of that sum. We have to find a subset with sum `i` such that `S/2 -i` is minimum.

Whether or not, there is a subset with sum `i` in the set is given by solving subset sum problem. For the sums, `i`, which are possible with subsets of the set, find the one which is the least distance from `S/2`. That will give us other subsets which are least greater than half of the sum of all elements of the set and that will be minimal difference possible between two subsets.

So, expression would be as

min(S/2 - i) where T[n][i] = True and i>=0 and i<=S/2

Why we took `i` >=0 and `i`<`S/2`? Because, we want to be balanced, so `i` cannot be more than half of the total sum in any case.

### Balanced partition problem implementation

package com.company; /** * Created by sangar on 25.11.18. */ public class BalancedPartition { public int findBalancePartition(int[] a){ // Calculate sum of all the elements in set int S = 0; for (int i=0; i<a.length; i++) S += a[i]; boolean T[][] = new boolean[a.length + 1][S + 1]; /* Initialize the first column as true. 0 sum is possible with all elements. */ for (int i=0; i<=a.length; i++) T[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<=S; i++) T[0][i] = false; for (int i = 1; i <= a.length; i++) { for (int j = 1; j <= S; j++) { // If ith element is excluded T[i][j] = T[i - 1][j]; // If ith element is included if (a[i - 1] <= j) T[i][j] |= T[i - 1][j - a[i - 1]]; } } // Initialize difference of two sums. int diff = Integer.MAX_VALUE; for (int j = S/2; j >= 0; j--) { // Find the if (T[a.length][j] == true) { diff = S - 2 * j; break; } } return diff; } }

Once, we get the nearest sum, we can always backtrack the table and find elements of the subset itself. Actually, this problem is now reduced to 0/1 knapsack problem, where maximum value we can get is j from the set of integers.

Complexity to split set into two balanced partitions is `O(n * S)` with a space complexity of `O(n * S)`, where `S` will be the max value array can have.