Split array into two equal length subsets such that all repetitions of a number lies in a single subset

Given an array arr[] consisting of N integers, the task is to check if it is possible to split the integers into two equal length subsets such that all repetitions of any array element belongs to the same subset. If found to be true, print “Yes”. Otherwise, print “No”.

Examples:

Input: arr[] = {2, 1, 2, 3}
Output: Yes
Explanation:
One possible way of dividing the array is {1, 3} and {2, 2}

Input: arr[] = {1, 1, 1, 1}
Output: No

Naive Approach: The simplest approach to solve the problem is to try all possible combinations of splitting the array into two equal subsets. For each combination, check whether every repetition belongs to only one of the two sets or not. If found to be true, then print “Yes”. Otherwise, print “No”.

Time Complexity: O(2^N), where N is the size of the given integer.
Auxiliary Space: O(N)

Efficient Approach: The above approach can be optimized by storing the frequency of all elements of the given array in an array freq[]. For elements to be divided into two equal sets, N/2 elements must be present in each set. Therefore, to divide the given array arr[] into 2 equal parts, there must be some subset of integers in freq[] having sum N/2. Follow the steps below to solve the problem:

Store the frequency of each element in the Map M.
Now, create an auxiliary array aux[] and insert into it, all the frequencies stored from the Map.
The given problem reduces to finding a subset in the array aux[] having a given sum N/2.
If there exists any such subset in the above step, then print “Yes”. Otherwise, print “No”.

Below is the implementation of the above approach:

Java

// Java program for the above approach 
import java.io.*; 
import java.util.*; 
  
class GFG { 
  
    // Function to create the frequency 
    // array of the given array arr[] 
    private static int[] findSubsets(int[] arr) 
    { 
  
        // Hashmap to store the frequencies 
        HashMap<Integer, Integer> M 
            = new HashMap<>(); 
  
        // Store freq for each element 
        for (int i = 0; i < arr.length; i++) { 
            M.put(arr[i], 
                  M.getOrDefault(arr[i], 0) + 1); 
        } 
  
        // Get the total frequencies 
        int[] subsets = new int[M.size()]; 
        int i = 0; 
  
        // Store frequencies in subset[] array 
        for ( 
            Map.Entry<Integer, Integer> playerEntry : 
            M.entrySet()) { 
            subsets[i++] 
                = playerEntry.getValue(); 
        } 
  
        // Return frequency array 
        return subsets; 
    } 
  
    // Function to check is sum N/2 can be 
    // formed using some subset 
    private static boolean
    subsetSum(int[] subsets, 
              int target) 
    { 
  
        // dp[i][j] store the answer to 
        // form sum j using 1st i elements 
        boolean[][] dp 
            = new boolean[subsets.length 
                          + 1][target + 1]; 
  
        // Initialize dp[][] with true 
        for (int i = 0; i < dp.length; i++) 
            dp[i][0] = true; 
  
        // Fill the subset table in the 
        // bottom up manner 
        for (int i = 1; 
             i <= subsets.length; i++) { 
  
            for (int j = 1; 
                 j <= target; j++) { 
                dp[i][j] = dp[i - 1][j]; 
  
                // If curren element is 
                // less than j 
                if (j >= subsets[i - 1]) { 
  
                    // Update current state 
                    dp[i][j] 
                        |= dp[i - 1][j 
                                     - subsets[i - 1]]; 
                } 
            } 
        } 
  
        // Return the result 
        return dp[subsets.length][target]; 
    } 
  
    // Function to check if the given 
    // array can be split into required sets 
    public static void
    divideInto2Subset(int[] arr) 
    { 
        // Store frequencies of arr[] 
        int[] subsets = findSubsets(arr); 
  
        // If size of arr[] is odd then 
        // print "Yes" 
        if ((arr.length) % 2 == 1) { 
            System.out.println("No"); 
            return; 
        } 
  
        // Check if answer is true or not 
        boolean isPossible 
            = subsetSum(subsets, 
                        arr.length / 2); 
  
        // Print the result 
        if (isPossible) { 
            System.out.println("Yes"); 
        } 
        else { 
            System.out.println("No"); 
        } 
    } 
  
    // Driver Code 
    public static void main(String[] args) 
    { 
        // Given array arr[] 
        int[] arr = { 2, 1, 2, 3 }; 
  
        // Function Call 
        divideInto2Subset(arr); 
    } 
} 

Output:

Yes

Time Complexity: O(N*M), where N is the size of the array and M is the total count of distinct elements in the given array.
Auxiliary Space: O(N)

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.

My Personal Notes

Java

Recommended Posts: