Split array into two equal length subsets such that all repetitions of a number lies in a single subset
Last Updated :
07 May, 2023
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:
- Store the frequency of each element in Map M.
- Now, create an auxiliary array aux[] and insert it 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:
C++
#include <bits/stdc++.h>
using namespace std;
vector< int > findSubsets(vector< int > arr, int N)
{
map< int , int > M;
for ( int i = 0; i < N; i++)
{
M[arr[i]]++;
}
vector< int > subsets;
int I = 0;
for ( auto playerEntry = M.begin(); playerEntry != M.end(); playerEntry++)
{
subsets.push_back(playerEntry->second);
I++;
}
return subsets;
}
bool subsetSum(vector< int > subsets, int N, int target)
{
bool dp[N + 1][target + 1];
for ( int i = 0; i < N + 1; i++)
dp[i][0] = true ;
for ( int i = 1; i <= N; i++)
{
for ( int j = 1; j <= target; j++)
{
dp[i][j] = dp[i - 1][j];
if (j >= subsets[i - 1])
{
dp[i][j] |= dp[i - 1][j - subsets[i - 1]];
}
}
}
return dp[N][target];
}
void divideInto2Subset(vector< int > arr, int N)
{
vector< int > subsets = findSubsets(arr, N);
if ((N) % 2 == 1)
{
cout << "No" << endl;
return ;
}
int subsets_size = subsets.size();
bool isPossible = subsetSum(subsets, subsets_size, N / 2);
if (isPossible)
{
cout << "Yes" << endl;
}
else
{
cout << "No" << endl;
}
}
int main()
{
vector< int > arr{2, 1, 2, 3};
int N = arr.size();
divideInto2Subset(arr, N);
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG {
private static int [] findSubsets( int [] arr)
{
HashMap<Integer, Integer> M
= new HashMap<>();
for ( int i = 0 ; i < arr.length; i++) {
M.put(arr[i],
M.getOrDefault(arr[i], 0 ) + 1 );
}
int [] subsets = new int [M.size()];
int i = 0 ;
for (
Map.Entry<Integer, Integer> playerEntry :
M.entrySet()) {
subsets[i++]
= playerEntry.getValue();
}
return subsets;
}
private static boolean
subsetSum( int [] subsets,
int target)
{
boolean [][] dp
= new boolean [subsets.length
+ 1 ][target + 1 ];
for ( int i = 0 ; i < dp.length; i++)
dp[i][ 0 ] = true ;
for ( int i = 1 ;
i <= subsets.length; i++) {
for ( int j = 1 ;
j <= target; j++) {
dp[i][j] = dp[i - 1 ][j];
if (j >= subsets[i - 1 ]) {
dp[i][j]
|= dp[i - 1 ][j
- subsets[i - 1 ]];
}
}
}
return dp[subsets.length][target];
}
public static void
divideInto2Subset( int [] arr)
{
int [] subsets = findSubsets(arr);
if ((arr.length) % 2 == 1 ) {
System.out.println( "No" );
return ;
}
boolean isPossible
= subsetSum(subsets,
arr.length / 2 );
if (isPossible) {
System.out.println( "Yes" );
}
else {
System.out.println( "No" );
}
}
public static void main(String[] args)
{
int [] arr = { 2 , 1 , 2 , 3 };
divideInto2Subset(arr);
}
}
|
Python3
from collections import defaultdict
def findSubsets(arr):
M = defaultdict ( int )
for i in range ( len (arr)):
M[arr[i]] + = 1
subsets = [ 0 ] * len (M)
i = 0
for j in M:
subsets[i] = M[j]
i + = 1
return subsets
def subsetSum(subsets, target):
dp = [[ 0 for x in range (target + 1 )]
for y in range ( len (subsets) + 1 )]
for i in range ( len (dp)):
dp[i][ 0 ] = True
for i in range ( 1 , len (subsets) + 1 ):
for j in range ( 1 , target + 1 ):
dp[i][j] = dp[i - 1 ][j]
if (j > = subsets[i - 1 ]):
dp[i][j] | = (dp[i - 1 ][j -
subsets[i - 1 ]])
return dp[ len (subsets)][target]
def divideInto2Subset(arr):
subsets = findSubsets(arr)
if ( len (arr) % 2 = = 1 ):
print ( "No" )
return
isPossible = subsetSum(subsets,
len (arr) / / 2 )
if (isPossible):
print ( "Yes" )
else :
print ( "No" )
if __name__ = = "__main__" :
arr = [ 2 , 1 , 2 , 3 ]
divideInto2Subset(arr)
|
C#
using System;
using System.Collections.Generic;
class GFG{
static int [] findSubsets( int [] arr)
{
Dictionary< int ,
int > M =
new Dictionary< int ,
int >();
for ( int i = 0; i < arr.Length; i++)
{
if (M.ContainsKey(arr[i]))
{
M[arr[i]]++;
}
else
{
M[arr[i]] = 1;
}
}
int [] subsets = new int [M.Count];
int I = 0;
foreach (KeyValuePair< int ,
int >
playerEntry in M)
{
subsets[I] = playerEntry.Value;
I++;
}
return subsets;
}
static bool subsetSum( int [] subsets,
int target)
{
bool [,] dp = new bool [subsets.Length + 1,
target + 1];
for ( int i = 0;
i < dp.GetLength(0); i++)
dp[i, 0] = true ;
for ( int i = 1;
i <= subsets.Length; i++)
{
for ( int j = 1; j <= target; j++)
{
dp[i, j] = dp[i - 1, j];
if (j >= subsets[i - 1])
{
dp[i, j] |= dp[i - 1,
j - subsets[i - 1]];
}
}
}
return dp[subsets.Length,
target];
}
static void divideInto2Subset( int [] arr)
{
int [] subsets = findSubsets(arr);
if ((arr.Length) % 2 == 1)
{
Console.WriteLine( "No" );
return ;
}
bool isPossible = subsetSum(subsets,
arr.Length / 2);
if (isPossible)
{
Console.WriteLine( "Yes" );
}
else
{
Console.WriteLine( "No" );
}
}
static void Main()
{
int [] arr = {2, 1, 2, 3};
divideInto2Subset(arr);
}
}
|
Javascript
<script>
function findSubsets( arr, N)
{
let M = new Map();
for (let i = 0; i < N; i++)
{
if (M[arr[i]])
M[arr[i]]++;
else
M[arr[i]] = 1
}
let subsets = [];
let I = 0;
for ( var it in M)
{
subsets.push(M[it]);
}
return subsets;
}
function subsetSum( subsets, N, target)
{
var dp = [],
H = N+1;
W = target+1;
for ( var y = 0; y < H; y++ ) {
dp[ y ] = [];
for ( var x = 0; x < W; x++ ) {
dp[ y ][ x ] = false ;
}
}
for (let i = 0; i < N + 1; i++)
dp[i][0] = true ;
for (let i = 1; i <= N; i++)
{
for (let j = 1; j <= target; j++)
{
dp[i][j] = dp[i - 1][j];
if (j >= subsets[i - 1])
{
dp[i][j] |= dp[i - 1][j - subsets[i - 1]];
}
}
}
return dp[N][target];
}
function divideInto2Subset( arr, N)
{
let subsets = findSubsets(arr, N);
if ((N) % 2 == 1)
{
document.write( "No<br>" );
return ;
}
let subsets_size = subsets.length;
let isPossible = subsetSum(subsets,
subsets_size, Math.floor(N / 2));
if (isPossible)
{
document.write( "Yes<br>" );
}
else
{
document.write( "No<br>" );
}
}
let arr = [2, 1, 2, 3];
let N = arr.length;
divideInto2Subset(arr, N);
</script>
|
Time Complexity: O(N*Target) where target is N/2
Auxiliary Space: O(N*Target)
Efficient Approach : Space optimization
In previous approach the current computation Dp[i][j] is only depend upon the current row and previous row of DP. So we can optimize the space by using a 1D array to store these computations.
Implementation Steps:
- Create a DP array of size target+1 and initialize it with False.
- Set base case by initializing dp[0] = true.
- Now iterate over subproblems with the help of nested loops and get the current value from the previous computations.
- At last return final answer stored in dp[target].
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
vector< int > findSubsets(vector< int >& arr, int N)
{
map< int , int > M;
for ( int i = 0; i < N; i++)
{
M[arr[i]]++;
}
vector< int > subsets;
for ( auto playerEntry = M.begin(); playerEntry != M.end(); playerEntry++)
{
subsets.push_back(playerEntry->second);
}
return subsets;
}
bool subsetSum(vector< int >& subsets, int N, int target)
{
bool dp[target + 1];
memset (dp, false , sizeof (dp));
dp[0] = true ;
for ( int i = 1; i <= N; i++)
{
for ( int j = target; j >= 1; j--)
{
if (j >= subsets[i - 1])
{
dp[j] |= dp[j - subsets[i - 1]];
}
}
}
return dp[target];
}
void divideInto2Subset(vector< int >& arr, int N)
{
vector< int > subsets = findSubsets(arr, N);
if ((N) % 2 == 1)
{
cout << "No" << endl;
return ;
}
int subsets_size = subsets.size();
bool isPossible = subsetSum(subsets, subsets_size, N / 2);
if (isPossible)
{
cout << "Yes" << endl;
}
else
{
cout << "No" << endl;
}
}
int main()
{
vector< int > arr{2, 1, 2, 3};
int N = arr.size();
divideInto2Subset(arr, N);
return 0;
}
|
Java
import java.util.*;
public class Main {
static List<Integer> findSubsets(List<Integer> arr,
int N)
{
Map<Integer, Integer> M = new HashMap<>();
for ( int i = 0 ; i < N; i++) {
int element = arr.get(i);
if (M.containsKey(element)) {
M.put(element, M.get(element) + 1 );
}
else {
M.put(element, 1 );
}
}
List<Integer> subsets = new ArrayList<>();
for (Map.Entry<Integer, Integer> entry :
M.entrySet()) {
subsets.add(entry.getValue());
}
return subsets;
}
static boolean subsetSum(List<Integer> subsets, int N,
int target)
{
boolean [] dp = new boolean [target + 1 ];
Arrays.fill(dp, false );
dp[ 0 ] = true ;
for ( int i = 1 ; i <= N; i++) {
for ( int j = target; j >= 1 ; j--) {
if (j >= subsets.get(i - 1 )) {
dp[j] |= dp[j - subsets.get(i - 1 )];
}
}
}
return dp[target];
}
static void divideInto2Subset(List<Integer> arr, int N)
{
List<Integer> subsets = findSubsets(arr, N);
if ((N) % 2 == 1 ) {
System.out.println( "No" );
return ;
}
int subsets_size = subsets.size();
boolean isPossible
= subsetSum(subsets, subsets_size, N / 2 );
if (isPossible) {
System.out.println( "Yes" );
}
else {
System.out.println( "No" );
}
}
public static void main(String[] args)
{
List<Integer> arr
= new ArrayList<>(Arrays.asList( 2 , 1 , 2 , 3 ));
int N = arr.size();
divideInto2Subset(arr, N);
}
}
|
Python3
def findSubsets(arr, N):
M = {}
for i in range (N):
if arr[i] not in M:
M[arr[i]] = 1
else :
M[arr[i]] + = 1
subsets = []
for playerEntry in M:
subsets.append(M[playerEntry])
return subsets
def subsetSum(subsets, N, target):
dp = [ False ] * (target + 1 )
dp[ 0 ] = True
for i in range ( 1 , N + 1 ):
for j in range (target, 0 , - 1 ):
if j > = subsets[i - 1 ]:
dp[j] | = dp[j - subsets[i - 1 ]]
return dp[target]
def divideInto2Subset(arr, N):
subsets = findSubsets(arr, N)
if (N) % 2 = = 1 :
print ( "No" )
return
subsets_size = len (subsets)
isPossible = subsetSum(subsets, subsets_size, N / / 2 )
if isPossible:
print ( "Yes" )
else :
print ( "No" )
arr = [ 2 , 1 , 2 , 3 ]
N = len (arr)
divideInto2Subset(arr, N)
|
C#
using System;
using System.Collections.Generic;
public class Program {
public static List< int > findSubsets(List< int > arr, int N) {
Dictionary< int , int > M = new Dictionary< int , int >();
for ( int i = 0; i < N; i++) {
if (!M.ContainsKey(arr[i])) {
M[arr[i]] = 1;
}
else {
M[arr[i]] += 1;
}
}
List< int > subsets = new List< int >();
foreach (KeyValuePair< int , int > playerEntry in M) {
subsets.Add(playerEntry.Value);
}
return subsets;
}
public static bool subsetSum(List< int > subsets, int N, int target) {
bool [] dp = new bool [target+1];
dp[0] = true ;
for ( int i = 1; i <= N; i++) {
for ( int j = target; j > 0; j--) {
if (j >= subsets[i - 1]) {
dp[j] |= dp[j - subsets[i - 1]];
}
}
}
return dp[target];
}
public static void divideInto2Subset(List< int > arr, int N) {
List< int > subsets = findSubsets(arr, N);
if (N % 2 == 1) {
Console.WriteLine( "No" );
return ;
}
int subsets_size = subsets.Count;
bool isPossible = subsetSum(subsets, subsets_size, N / 2);
if (isPossible) {
Console.WriteLine( "Yes" );
} else {
Console.WriteLine( "No" );
}
}
public static void Main( string [] args) {
List< int > arr = new List< int >() {2, 1, 2, 3};
int N = arr.Count;
divideInto2Subset(arr, N);
}
}
|
Javascript
function findSubsets(arr, N) {
let M = new Map();
for (let i = 0; i < N; i++) {
if (M.has(arr[i])) {
M.set(arr[i], M.get(arr[i]) + 1);
} else {
M.set(arr[i], 1);
}
}
let subsets = [];
for (let [key, value] of M) {
subsets.push(value);
}
return subsets;
}
function subsetSum(subsets, N, target) {
let dp = new Array(target + 1).fill( false );
dp[0] = true ;
for (let i = 1; i <= N; i++) {
for (let j = target; j >= 1; j--) {
if (j >= subsets[i - 1]) {
dp[j] |= dp[j - subsets[i - 1]];
}
}
}
return dp[target];
}
function divideInto2Subset(arr, N) {
let subsets = findSubsets(arr, N);
if (N % 2 === 1) {
console.log( "No" );
return ;
}
let subsets_size = subsets.length;
let isPossible = subsetSum(subsets, subsets_size, N / 2);
if (isPossible) {
console.log( "Yes" );
} else {
console.log( "No" );
}
}
let arr = [2, 1, 2, 3];
let N = arr.length;
divideInto2Subset(arr, N);
|
Output
Yes
Time Complexity: O(N*Target) where target is N/2
Auxiliary Space: O(Target)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...