Tug of War in Java

In the tug of war problem, we have to divide the given set of n integers into two sets of equal or almost equal sizes. The given set must be divided in such a way that the difference of the sum of integers present in the first subset and the second subset must be minimum. If the value of n is even, then the size of each set must be equal to n / 2. If the value of n is odd, then the size of one set must be n / 2, and the size of the other set is (n + 1) / 2. Let's understand it with the help of a few examples.

Note: Minimum mentioned above means the value of the difference of the two subsets. In other words, the sign of the value has to be ignored. Only magnitude is considered.

Example 1:

S = {-3, 5, 4, 3, 1, 100, 54, 89, 20, 23}, where S is set that contains 10 elements.

It is obvious that 10 is an even number. Thus, the two subsets that we will create from the given set must be of the size 5 (10 / 2 = 5) each. Those two subsets are:

S1 = {4, 1, 100, 20, 23} and S2 = {-3, 5, 3, 54, 89}

The sum of the subset S1 is 4 + 1 + 100 + 20 + 23 = 148

The sum of the subset S2 is -3 + 5 + 3 + 54 + 89 = 148

Thus, we see that sum of subset S1 is equal to the sum of subset S2. Thus, the difference of the two subsets is 148 - 148 = 0, which is minimum.

Example 2:

S = {-34, 23, 98, 45, 12, 4, 4, -99, -1, 189, 0}, where S is set that contains 11 elements.

It is obvious that 11 is an odd number. Thus, the two subsets that we will create from the given set must be of the size 5 (10 / 2 = 5) and 6 (10 / 5 + 1 = 6), respectively. Those two subsets are:

S1 = {45, -34, 12, 98, -1} and S2 = {23, 4, 4, -99, 189, 0}

The sum of the subset S1 is 45 -34 + 12 + 98 -1 = 120

The sum of the subset S2 is 23 + 4 + 4 -99 + 189 + 0 = 121

Thus, we see that sum of subset S1 is equal to the sum of subset S2. Thus, the difference of the two subsets is 121 - 120 = 1. If we make any other pair of subsets of the same size, we cannot get the difference less than 1. Thus, 1 is minimum difference possible for the given set.

Approach

The following solution looks for each and every possible subset of the half size. If the first subset of the half of size is created, then the rest of the elements create another subset. We initialize the current set as an empty set and then fill elements in it. For every element, we have two possibilities: one is to include the element in the current set, and the other is to exclude the element from the current set. By considering these two possibilities, we fill the subsets.

Implementation

Let's see the implementation of the tug of war problem using the approach mentioned above.

FileName: TugOfWarEx.java

public class TugOfWarEx
{
public int minDiff;

// a utility method that tries each and every solution 
// possible by invoking itself recursively
void TOWUtil(int array[], int size, boolean currElements[],
int noOfSelectedElements, boolean sol[],
int sum, int currSum, int currPosition)
{
// checking whether the currPosition 
// is going out of the bound or not
if (currPosition == size)
{
return;
}

// checking for the numbers of remaining elements
// are not less than the number of elements required
// to construct the solution
if ((size / 2 - noOfSelectedElements) > (size - currPosition))
{
return;
}

// consider the cases when current element
// is not included in the solution
TOWUtil(array, size, currElements, 
noOfSelectedElements, sol, 
sum, currSum, currPosition + 1);

// adding the current element 
// to the solution
noOfSelectedElements = noOfSelectedElements + 1;
currSum = currSum + array[currPosition];
currElements[currPosition] = true;

// checking whether the solution is formed or not
if (noOfSelectedElements == size / 2)
{
// checking whether the solution build is
// better than the best solution found so far
if (Math.abs(sum / 2 - currSum) < minDiff)
{
minDiff = Math.abs(sum / 2 - currSum);
for (int j = 0; j < size; j++)
{
sol[j] = currElements[j];
}
}
}
else
{
// the following recursive call includes the current element
// in the solution
TOWUtil(array, size, currElements,
noOfSelectedElements,
sol, sum, currSum,
currPosition + 1);
}

// removing the current element 
// before returning to the caller  
// of this method
currElements[currPosition] = false;
}

// main method that generates an array
void tugOfWar(int array[])
{
int size = array.length;

// the boolean arrayay that contains the
// inclusion and exclusion of an element
// in current set. The number excluded
// automatically form the other set
boolean[] currElements = new boolean[size];

// The inclusion/exclusion arrayay for
// final solution
boolean[] sol = new boolean[size];

minDiff = Integer.MAX_VALUE;

int sum = 0;
for (int j = 0; j < size; j++)
{
sum = sum + array[j];
currElements[j] = sol[j] = false;
}

// Find the solution using recursive
// function TOWUtil()
TOWUtil(array, size, currElements, 0,
sol, sum, 0, 0);

// Displaying the solution
System.out.print("The elements of the first subset are: ");
for (int j = 0; j < size; j++)
{
if (sol[j] == true)
{
System.out.print(array[j] + " ");
}
}

System.out.print("\n");
System.out.print("The elements of the second subset are: ");
for (int j = 0; j < size; j++)
{
if (sol[j] == false)
{
System.out.print(array[j] + " ");
}
}
}

// Main method
public static void main (String[] argvs)
{
// the input array
int array[] = new int[]{-34, 23, 98, 45, 12, 4, 4, -99, -1, 189, 0};

// computing the size of the input array
int size = array.length; 

// creating an object of the class TugOfWarEx 			
TugOfWarEx obj = new TugOfWarEx();

System.out.println("For the array: ");
for(int i = 0; i < size; i++)
{
System.out.print(array[i] + " ");
}

System.out.println();

// invoking the method tugOfWar() 
obj.tugOfWar(array);

// updating input array
array = new int[]{-3, 5, 4, 3, 1, 100, 54, 89, 20, 23};

// computing the size of the input array
size = array.length;

System.out.println("\n");

System.out.println("For the array: ");
for(int i = 0; i < size; i++)
{
System.out.print(array[i] + " ");
}

System.out.println();

// invoking the method tugOfWar() 
obj.tugOfWar(array);


}
}

Output:

For the array: 
-34 23 98 45 12 4 4 -99 -1 189 0 
The elements of the first subset are: -34 98 45 12 -1 
The elements of the second subset are: 23 4 4 -99 189 0 

For the array: 
-3 5 4 3 1 100 54 89 20 23 
The elements of the first subset are: 4 1 100 20 23 
The elements of the second subset are: -3 5 3 54 89

Time Complexity: The time complexity of the above program is 2ⁿ, where n is the number of elements present in the array.

Next TopicClone HashMap in Java

← prev next →