Three Partition Problem in Java

It is very interesting problem frequently asked in interviews of top IT companies like Google, Amazon, TCS, Accenture, etc. By solving the problem, one wants to check the logical ability, critical thinking, and problem-solving skill of the interviewee. So, in this section, we are going to solve three partition problem in Java with different approaches and logic. Also, we will create Java programs for the same.

Problem Statement

An array of non-negative numbers is given. Our task is to check whether the input array can be partitioned into the three completely disjoint subsets or not, such that the sum of all the elements of one subset is equal to the sum of all the elements of the other subset. Note that all the elements of the input array have to be included. Display appropriate messages on the console accordingly.

Example 1:

Input

int inputArr[] = {3, 7, 1, 2, 4, 5, 8}

Output: The given input array can be partitioned into three disjoint subsets of an equal sum of elements.

Explanation: Consider the following subsets.

Subset1 = {3, 7} sum = 3 + 7 = 1=, Subset2 = {1, 4, 5} sum = 1 + 4 + 5 = 10,

Subset3 = {2, 8} sum = 2 + 8 = 10

Thus, we see that we got the three subsets of an equal sum of elements.

Example 2:

Input

int inputArr[] = {6, 2, 3, 9, 8, 18, 96}

Output: The given input array cannot be partitioned into three disjoint subsets of an equal sum of elements.

Explanation: Any set of three subsets will not give the equal sum of elements for the given input array.

Approach: Using Recursion

First of all, we will check whether the sum of all the elements of the input array is a multiple of 3 or not. If it is not the multiple of 3, then it is not possible to do the partition. If yes, then we have to check whether three disjoint sets exist or not whose sum of elements is equal to (total sum of elements of the input array) / 3 or not. It can be found by considering each element of the input array one by one. For every element, there are the following three possibilities:

1) Consider the element for the first subset, and apply recursion for the other elements.

2) Consider the element for the second subset, and apply recursion for the other elements.

3) Consider the element for the third subset, and apply recursion for the other elements.
Since we have to include every item of the input array, the base case of the recursion will be when all the items of the input array have been considered. The recursion will return true when three disjoint subsets are found.

FileName: ThreePartition.java

public class ThreePartition
{
    // Helper method for computing the 3-partition problem.
    // If it returns true, then there exist three disjoint subsets with the sum
    public boolean disjointSubsetSum(int arr[], int size, int i, int j, int k)
    {
        // return true if the subset is found
        if (i == 0 && j == 0 && k == 0) 
        {
            return true;
        }
 
        // handling the base case: when no items are left
        if (size < 0) 
        {
            return false;
        }
 
        // Case 1: The first subset contains the current element
        boolean c1 = false;
        if (i - arr[size] >= 0) {
            c1 = disjointSubsetSum(arr, size - 1, i - arr[size], j, k);
        }
 
        // Case 2: The second subset contains the current element
        boolean c2 = false;
        if (!c1 && (j - arr[size] >= 0)) 
        {
            c2 = disjointSubsetSum(arr, size - 1, i, j - arr[size], k);
        }
 
        // Case 3: The third subset contains the current element
        boolean c3 = false;
        if ((!c1 && !c2) && (k - arr[size] >= 0)) 
        {
            c3 = disjointSubsetSum(arr, size - 1, i, j, k - arr[size]);
        }
 
        // if either of the three cases is true, then we can return true
        return c1 || c2 || c3;
    }
 
    // method for computing the 3 partitions problem. It returns true if the given
    // set `arr[0 ... n - 1]` can be split into a set of three disjoint subsets with the equal sum.
    public boolean partitionInThree(int arr[])
    {
        // it is obvious that for the three disjoint subsets
        // there have to be at least three elements present in the given array
        if (arr.length < 3) 
        {
            return false;
        }
 
        // get the sum of all of the elements of the given array
        int sumOfEle = 0;
        for(int i = 0; i < arr.length; i++)
        {
            sumOfEle = sumOfEle + arr[i];
        }
 
        // return true if the sum of all the elements is divisible by 3 and 
        // the input array can be divided into the three disjoint subsets with the equal sum
        if((sumOfEle % 3) == 0)
        {
            if (disjointSubsetSum(arr, arr.length - 1, sumOfEle / 3, sumOfEle / 3, sumOfEle / 3))
            {
            return true;
            }
            return false;
        }
        return false;
    }
 
    // main method 
    public static void main(String argvs[])
    {
        // creating an object of the class 
        ThreePartition obj = new ThreePartition();
        
        // Input 1
        int arr[] = {3, 7, 1, 2, 4, 5, 8};
        
        int size = arr.length;
        
        System.out.println("For the input array: ");
        for(int i = 0; i < size; i++)
        {
            System.out.print(arr[i]+ " ");
        }
        System.out.println();
        if (obj.partitionInThree(arr)) 
        {
            System.out.println("It is possible to partition it into three disjoint subsets.");
        }
        else 
        {
            System.out.println("It is not possible to partition it into three disjoint subsets.");
        }
        
        System.out.println();
        
        // Input 2
        int arr2[] = {6, 2, 3, 9, 8, 18, 96};
        size = arr2.length;
        System.out.println("For the input array: ");
        for(int i = 0; i < size; i++)
        {
            System.out.print(arr2[i]+ " ");
        }
        System.out.println();
        if (obj.partitionInThree(arr2)) 
        {
            System.out.println("It is possible to partition it into three disjoint subsets.");
        }
        else 
        {
            System.out.println("It is not possible to partition it into three disjoint subsets.");
        }
    }
}

Output:

For the input array: 
3 7 1 2 4 5 8 
It is possible to partition it into three disjoint subsets.

For the input array: 
6 2 3 9 8 18 96 
It is not possible to partition it into three disjoint subsets.

Complexity Analysis: The time complexity of the above program is exponential.

The above program gives the correct output but will consume a lot of time giving the output. Thus, it is not suitable to handle an input of a large size.

Approach: Using Dynamic Programming

To reduce the time complexity, we can take the help of dynamic programming. Observe the following program.

FileName: ThreePartition.java

// important import statement
import java.util.*;
public class ThreePartition
{
    // Helper method for computing the 3-partition problem.
    // If it returns true, then there exist three disjoint subsets with the sum
    public boolean disjointSubsetSum(int arr[], int size, int i, int j, int k, Map<String, Boolean> dp)
    {
        // return true if the subset is found
        if (i == 0 && j == 0 && k == 0) 
        {
            return true;
        }
        // handling the base case: when no items are left
        if (size < 0) 
        {
            return false;
        }
        // constructing a unique key
        String key = i + "|" + j + "|" + j + "|" + size;
        
        if(!dp.containsKey(key))
        {
        // Case 1: The first subset contains the current eleement
        boolean c1 = false;
        if (i - arr[size] >= 0) {
            c1 = disjointSubsetSum(arr, size - 1, i - arr[size], j, k, dp);
        }
        // Case 2: The second subset contains the current eleement
        boolean c2 = false;
        if (!c1 && (j - arr[size] >= 0)) 
        {
            c2 = disjointSubsetSum(arr, size - 1, i, j - arr[size], k, dp);
        }
        // Case 3: The third subset contains the current eleement
        boolean c3 = false;
        if ((!c1 && !c2) && (k - arr[size] >= 0)) 
        {
            c3 = disjointSubsetSum(arr, size - 1, i, j, k - arr[size], dp);
        }
        // if either of the three cases is true, then we can return true
        dp.put(key, c1 || c2 || c3) ;
        }
        return dp.get(key);
    }
    // method for computing the 3 partitions problem. It returns true if the given
    // set `arr[0 ... n - 1]` can be split into a set of three disjoint subsets with the equal sum.
    public boolean partitionInThree(int arr[])
    {
        // it is obvious that for the three disjoint subsets
        // there have to be at least three elements present in the given array
        if (arr.length < 3) 
        {
            return false;
        }
        // get the sum of all of the elements of the given array
        int sumOfEle = 0;
        for(int i = 0; i < arr.length; i++)
        {
            sumOfEle = sumOfEle + arr[i];
        }
        // creating a map for keeping the solution of the subproblems 
        // so that they are not computed
        Map<String, Boolean> dp = new HashMap<>();
        // return true if the sum of all the elements is divisible by 3 and 
        // the input array can be divided into the three disjoint subsets with the equal sum
        if((sumOfEle % 3) == 0)
        {
            if (disjointSubsetSum(arr, arr.length - 1, sumOfEle / 3, sumOfEle / 3, sumOfEle / 3, dp))
            {
            return true;
            }
            return false;
        }
        return false;
    }
    // main method 
    public static void main(String argvs[])
    {
        // creating an object of the class 
        ThreePartition obj = new ThreePartition();
        // Input 1
        int arr[] = {3, 7, 1, 2, 4, 5, 8};
        int size = arr.length;
        System.out.println("For the input array: ");
        for(int i = 0; i < size; i++)
        {
            System.out.print(arr[i]+ " ");
        }
        System.out.println();
        if (obj.partitionInThree(arr)) 
        {
            System.out.println("It is possible to partition it into three disjoint subsets.");
        }
        else 
        {
            System.out.println("It is not possible to partition it into three disjoint subsets.");
        }
        System.out.println();
        // Input 2
        int arr2[] = {6, 2, 3, 9, 8, 18, 96};
        size = arr2.length;
        System.out.println("For the input array: ");
        for(int i = 0; i < size; i++)
        {
            System.out.print(arr2[i]+ " ");
        }
        System.out.println();
        if (obj.partitionInThree(arr2)) 
        {
            System.out.println("It is possible to partition it into three disjoint subsets.");
        }
        else 
        {
            System.out.println("It is not possible to partition it into three disjoint subsets.");
        }
    }
}

Output:

For the input array: 
3 7 1 2 4 5 8 
It is possible to partition it into three disjoint subsets.

For the input array: 
6 2 3 9 8 18 96 
It is not possible to partition it into three disjoint subsets.

Complexity Analysis: The time complexity of the above program is O(sum³ × n) and also consumes O(sum³ × n) extra space, where the sum is the sum of all the elements of the input array, and n is the total number of elements of the input array.

Extension to The Problem

Another thing that can be asked by an interviewer is to print those three disjoint subsets whose sum is equal. For that, an array will be required to keep track of all the disjoint subset elements. Observe the following program.

FileName: ThreePartition.java

public class ThreePartition
{
    // Helper method for computing the 3-partition problem.
    // If it returns true, then there exists three disjoint subsets with the sum
    public boolean disjointSubsetSum(int arr[], int size, int i, int j, int k, int store[])
    {
        // return true if the subset is found
        if (i == 0 && j == 0 && k == 0) 
        {
            return true;
        }
 
        // handling the base case: when no items are left
        if (size < 0) 
        {
            return false;
        }
        

        // Case 1: The first subset contains the current element
        boolean c1 = false;
        if (i - arr[size] >= 0) 
        {
            // keeping track of the current element. 1 means the first subset
            store[size] = 1;
            c1 = disjointSubsetSum(arr, size - 1, i - arr[size], j, k, store);
        }
 
        // Case 2: The second subset contains the current element
        boolean c2 = false;
        if (!c1 && (j - arr[size] >= 0)) 
        {
            // keeping track of the current element. 2 means the second subset.
            store[size] = 2;
            c2 = disjointSubsetSum(arr, size - 1, i, j - arr[size], k, store);
        }
 
        // Case 3: The third subset contains the current element
        boolean c3 = false;
        if ((!c1 && !c2) && (k - arr[size] >= 0)) 
        {
            // keeping track of the current element. 3 means the third subset.
            store[size] = 3;
            c3 = disjointSubsetSum(arr, size - 1, i, j, k - arr[size], store);
        }
 
        return (c1 || c2 || c3) ;
    }
 
    // method for computing the 3 partitions problem. It returns true if the given
    // set `arr[0 ... n - 1]` can be split into a set of three disjoint subsets with the equal sum.
    public boolean partitionInThree(int arr[], int store[])
    {
        // it is obvious that for the three disjoint subsets
        // there have to be at least three elements present in the given array
        if (arr.length < 3) 
        {
            return false;
        }
        // get the sum of all of the elements of the given array
        int sumOfEle = 0;
        for(int i = 0; i < arr.length; i++)
        {
            sumOfEle = sumOfEle + arr[i];
        }
        // return true if the sum of all the elements is divisible by 3 and 
        // the input array can be divided into the three disjoint subsets with the equal sum
        if((sumOfEle % 3) == 0)
        {
            if (disjointSubsetSum(arr, arr.length - 1, sumOfEle / 3, sumOfEle / 3, sumOfEle / 3, store))
            {
            return true;
            }
            return false;
        }
        return false;
    }
    void display(int arr[], int store[])
    {
        // print the partitions
        for (int j = 0; j < 3; j++)
        {
            System.out.print("Partition " + j + " is ");
            for (int k = 0; k < arr.length; k++)
            {
                if (store[k] == j + 1) {
                    System.out.print(arr[k] + " ");
                }
            }
            System.out.println();
        }
    }
    // main method 
    public static void main(String argvs[])
    {
        // creating an object of the class 
        ThreePartition obj = new ThreePartition();
        // Input 1
        int arr[] = {3, 7, 1, 2, 4, 5, 8};
        int size = arr.length;
        // for storing the elements of the disjoint subsets
        int[] store = new int[arr.length];
        
        System.out.println("For the input array: ");
        for(int i = 0; i < size; i++)
        {
            System.out.print(arr[i]+ " ");
        }
        System.out.println();
        if (obj.partitionInThree(arr, store)) 
        {
            System.out.println("It is possible to partition it into three disjoint subsets.");
            obj.display(arr, store);
        }
        else 
        {
            System.out.println("It is not possible to partition it into three disjoint subsets.");
        }
        System.out.println();
        // Input 2
        int arr2[] = {6, 2, 3, 9, 8, 18, 96};
        size = arr2.length;
        System.out.println("For the input array: ");
        for(int i = 0; i < size; i++)
        {
            System.out.print(arr2[i]+ " ");
        }
        System.out.println();
        if (obj.partitionInThree(arr2, store)) 
        {
            System.out.println("It is possible to partition it into three disjoint subsets.");
        }
        else 
        {
            System.out.println("It is not possible to partition it into three disjoint subsets.");
        }
    }
}

Output:

For the input array: 
3 7 1 2 4 5 8 
It is possible to partition it into three disjoint subsets.
Partition 0 is 2 8 
Partition 1 is 1 4 5 
Partition 2 is 3 7 

For the input array: 
6 2 3 9 8 18 96 
It is not possible to partition it into three disjoint subsets.

Next TopicCheck If the Given Array is Mirror Inverse in Java

← prev next →