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

• Last Updated : 08 Sep, 2021

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 belong 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(2N), 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:

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

Below is the implementation of the above approach:

C++

 // C++ program for the above approach#include using namespace std; // Function to create the frequency// array of the given array arr[]vector findSubsets(vector arr, int N){  // Hashmap to store the  // frequencies  map M;    // Store freq for each element  for (int i = 0; i < N; i++)  {      M[arr[i]]++;  }    // Get the total frequencies  vector subsets;  int I = 0;    // Store frequencies in  // subset[] array  for(auto playerEntry = M.begin(); playerEntry != M.end(); playerEntry++)  {      subsets.push_back(playerEntry->second);      I++;  }    // Return frequency array  return subsets;}  // Function to check is sum// N/2 can be formed using// some subsetbool subsetSum(vector subsets, int N, int target){  // dp[i][j] store the answer to  // form sum j using 1st i elements  bool dp[N + 1][target + 1];    // Initialize dp[][] with true  for (int i = 0; i < N + 1; i++)    dp[i] = true;    // Fill the subset table in the  // bottom up manner  for (int i = 1; i <= N; i++)  {    for (int j = 1; j <= target; j++)    {      dp[i][j] = dp[i - 1][j];        // If current 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[N][target];}  // Function to check if the given// array can be split into required setsvoid divideInto2Subset(vector arr, int N){  // Store frequencies of arr[]  vector subsets = findSubsets(arr, N);    // If size of arr[] is odd then  // print "Yes"  if ((N) % 2 == 1)  {    cout << "No" << endl;    return;  }     int subsets_size = subsets.size();     // Check if answer is true or not  bool isPossible = subsetSum(subsets, subsets_size, N / 2);    // Print the result  if (isPossible)  {    cout << "Yes" << endl;  }  else  {    cout << "No" << endl;  }} int main(){      // Given array arr[]      vector arr{2, 1, 2, 3};             int N = arr.size();             // Function Call      divideInto2Subset(arr, N);     return 0;}

Java

 // Java program for the above approachimport 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 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 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] = 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 current 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);    }} // This code is contributed by divyesh072019

Python3

 # Python3 program for the# above approachfrom collections import defaultdict # Function to create the# frequency array of the# given array arr[]def findSubsets(arr):     # Hashmap to store    # the frequencies    M = defaultdict (int)     # Store freq for each element    for i in range (len(arr)):        M[arr[i]] += 1               # Get the total frequencies    subsets =  * len(M)    i = 0     # Store frequencies in    # subset[] array    for j in M:        subsets[i] = M[j]        i += 1     # Return frequency array    return subsets # Function to check is# sum N/2 can be formed# using some subsetdef subsetSum(subsets, target):     # dp[i][j] store the answer to    # form sum j using 1st i elements    dp = [[0 for x in range(target + 1)]             for y in range(len(subsets) + 1)]     # Initialize dp[][] with true    for i in range(len(dp)):        dp[i] = True     # Fill the subset table in the    # bottom up manner    for i in range(1, len(subsets) + 1):        for j in range(1, target + 1):            dp[i][j] = dp[i - 1][j]             # If current 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[len(subsets)][target] # Function to check if the given# array can be split into required setsdef divideInto2Subset(arr):     # Store frequencies of arr[]    subsets = findSubsets(arr)     # If size of arr[] is odd then    # print "Yes"    if (len(arr) % 2 == 1):        print("No")        return        # Check if answer is true or not    isPossible = subsetSum(subsets,                           len(arr) // 2)     # Print the result    if (isPossible):        print("Yes")       else :        print("No") # Driver Codeif __name__ == "__main__":       # Given array arr    arr = [2, 1, 2, 3]     # Function Call    divideInto2Subset(arr) # This code is contributed by Chitranayal

C#

 // C# program for the above// approachusing System;using System.Collections.Generic;  class GFG{   // Function to create the frequency// array of the given array arr[]static int[] findSubsets(int[] arr){  // Hashmap to store the  // frequencies  Dictionary M =               new Dictionary();    // Store freq for each element  for (int i = 0; i < arr.Length; i++)  {    if(M.ContainsKey(arr[i]))    {      M[arr[i]]++;    }    else    {      M[arr[i]] = 1;    }  }   // Get the total frequencies  int[] subsets = new int[M.Count];  int I = 0;   // Store frequencies in  // subset[] array  foreach(KeyValuePair          playerEntry in M)  {    subsets[I] = playerEntry.Value;    I++;  }   // Return frequency array  return subsets;} // Function to check is sum// N/2 can be formed using// some subsetstatic bool subsetSum(int[] subsets,                      int target){  // dp[i][j] store the answer to  // form sum j using 1st i elements  bool[,] dp = new bool[subsets.Length + 1,                        target + 1];   // Initialize dp[][] with true  for (int i = 0;           i < dp.GetLength(0); 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 current 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 setsstatic 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)  {    Console.WriteLine("No");    return;  }   // Check if answer is true or not  bool isPossible = subsetSum(subsets,                              arr.Length / 2);   // Print the result  if (isPossible)  {    Console.WriteLine("Yes");  }  else  {    Console.WriteLine("No");  }}     // Driver codestatic void Main(){  // Given array arr[]  int[] arr = {2, 1, 2, 3};   // Function Call  divideInto2Subset(arr);}} // This code is contributed by divyeshrabadiya07

Javascript


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)

My Personal Notes arrow_drop_up