Open In App

Split an array containing N elements into K sets of distinct elements

Improve
Improve
Like Article
Like
Save
Share
Report

Given two integers N and K and an array arr[] consisting of duplicate elements, the task is to split N elements into K sets of distinct elements.
Examples: 
 

Input: N = 5, K = 2, arr[] = {3, 2, 1, 2, 3} 
Output: 
( 3 2 1 ) 
( 2 3 )
Input: N = 5, K = 2, arr[] = {2, 1, 1, 2, 1} 
Output: -1 
Explanation: 
It is not possible to split all the elements into K sets of distinct elements as 1 appears more than K times in the array. 
 

 

Approach: In order to solve the problem, we are using a map to store the frequency of every element. If the frequency of any element exceeds K, print -1. Maintain another map to store the sets for every respective frequencies. If no element has a frequency greater than K, print the sets for all corresponding frequencies as the required set.
Below is the implementation of the above approach: 
 

C++




// C++ Program to split N elements
// into exactly K sets consisting
// of no distinct elements
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if possible to
// split N elements into exactly K
// sets consisting of no distinct elements
void splitSets(int a[], int n, int k)
{
    // Store the frequency
    // of each element
    map<int, int> freq;
 
    // Store the required sets
    map<int, vector<int> > ans;
 
    for (int i = 0; i < n; i++) {
        // If frequency of a
        // particular element
        // exceeds K
        if (freq[a[i]] + 1 > k) {
            // Not possible
            cout << -1 << endl;
            return;
        }
 
        // Increase the frequency
        freq[a[i]] += 1;
        // Store the element for the
        // respective set
        ans[freq[a[i]]].push_back(a[i]);
    }
 
    // Display the sets
    for (auto it : ans) {
        cout << "( ";
        for (int i : it.second) {
            cout << i << " ";
        }
        cout << ")\n";
    }
}
 
// Driver code
int main()
{
 
    int arr[] = { 2, 1, 2, 3, 1,
                  4, 1, 3, 1, 4 };
    int n = sizeof(arr) / sizeof(int);
 
    int k = 4;
 
    splitSets(arr, n, k);
 
    return 0;
}


Java




// Java program to split N elements
// into exactly K sets consisting
// of no distinct elements
import java.util.*;
 
class GFG{
     
// Function to check if possible to
// split N elements into exactly K
// sets consisting of no distinct elements
static void splitSets(int a[], int n, int k)
{
     
    // Store the frequency
    // of each element
    Map<Integer, Integer> freq = new HashMap<>();
 
    // Store the required sets
    Map<Integer,
        ArrayList<Integer>> ans = new HashMap<>();
 
    for(int i = 0; i < n; i++)
    {
         
        // If frequency of a
        // particular element
        // exceeds K
        if(freq.get(a[i]) != null)
        {
            if (freq.get(a[i]) + 1 > k)
            {
                 
                // Not possible
                System.out.println(-1);
                return;
            }
        }
         
        // Increase the frequency
        freq.put(a[i], freq.getOrDefault(a[i], 0) + 1 );
         
        // Store the element for the
        // respective set
        if( ans.get(freq.get(a[i])) == null)
            ans.put(freq.get(a[i]),
                    new ArrayList<Integer>());
         
        ans.get(freq.get(a[i])).add(a[i]);
    }
     
    // Display the sets
    for(ArrayList<Integer> it : ans.values())
    {
        System.out.print("( ");
        for(int i = 0; i < it.size() - 1; i++)
        {
            System.out.print(it.get(i) + " ");
        }
         
        System.out.print(it.get(it.size() - 1));
        System.out.println(" )");
    }
}
 
// Driver code   
public static void main (String[] args)
{
    int arr[] = { 2, 1, 2, 3, 1,
                  4, 1, 3, 1, 4 };
                 
    int n = arr.length;
    int k = 4;
     
    splitSets(arr, n, k);
}
}
 
// This code is contributed by coder001


Python3




# Python3 Program to split N elements
# into exactly K sets consisting
# of no distinct elements
 
# Function to check if possible to
# split N elements into exactly K
# sets consisting of no distinct elements
def splitSets(a, n, k) :
 
    # Store the frequency
    # of each element
    freq = {}
 
    # Store the required sets
    ans = {}
 
    for i in range(n) :
       
        # If frequency of a
        # particular element
        # exceeds K
        if a[i] in freq :
            if freq[a[i]] + 1 > k :
               
                # Not possible
                print(-1)
                return
 
        # Increase the frequency
        if a[i] in freq :
            freq[a[i]] += 1
        else :
            freq[a[i]] = 1
     
        # Store the element for the
        # respective set
        if freq[a[i]] in ans :
            ans[freq[a[i]]].append(a[i])
        else :
            ans[freq[a[i]]] = [a[i]]
      
    # Display the sets
    for it in ans :
        print("( ", end = "")
        for i in ans[it] :
            print(i , end = " ")
     
        print(")")
 
arr = [ 2, 1, 2, 3, 1, 4, 1, 3, 1, 4 ]
n = len(arr)
 
k = 4
 
splitSets(arr, n, k)
 
# This code is contributed by divyesh072019


C#




// C# Program to split N elements
// into exactly K sets consisting
// of no distinct elements
using System;
using System.Collections.Generic;
class GFG
{
 
  // Function to check if possible to
  // split N elements into exactly K
  // sets consisting of no distinct elements
  static void splitSets(int[] a, int n, int k)
  {
    // Store the frequency
    // of each element
    Dictionary<int, int> freq = new Dictionary<int, int>();
 
    // Store the required sets
    Dictionary<int, List<int>> ans = new Dictionary<int, List<int>>();
 
    for (int i = 0; i < n; i++)
    {
 
      // If frequency of a
      // particular element
      // exceeds K
      if(freq.ContainsKey(a[i]))
      {
        if(freq[a[i]] + 1 > k)
        {
 
          // Not possible
          Console.WriteLine(-1);
          return;
        }
      }
      else if(1 > k)
      {
         
        // Not possible
        Console.WriteLine(-1);
        return;
      }
 
      // Increase the frequency
      if(freq.ContainsKey(a[i]))
      {
        freq[a[i]] += 1;
      }
      else
      {
        freq[a[i]] = 1;
      }
 
      // Store the element for the
      // respective set
      if(ans.ContainsKey(freq[a[i]]))
      {
        ans[freq[a[i]]].Add(a[i]);
      }
      else
      {
        ans[freq[a[i]]] = new List<int>();
        ans[freq[a[i]]].Add(a[i]);
      }
 
    }
 
    // Display the sets
    foreach(KeyValuePair<int, List<int>> it in ans)
    {
      Console.Write("( ");
      foreach(int i in it.Value)
      {
        Console.Write(i + " ");
      }
      Console.WriteLine(")");
    }
  }
 
  // Driver code
  static void Main()
  {
    int[] arr = { 2, 1, 2, 3, 1,
                 4, 1, 3, 1, 4 };
    int n = arr.Length;
    int k = 4;
    splitSets(arr, n, k);
  }
}
 
// This code is contributed by divyeshrabadiya07


Javascript




// JS Program to split N elements
// into exactly K sets consisting
// of no distinct elements
 
// Function to check if possible to
// split N elements into exactly K
// sets consisting of no distinct elements
function splitSets(a, n, k)
{
 
    // Store the frequency
    // of each element
    let freq = {};
 
    // Store the required sets
    let ans = {};
 
    for (var i = 0; i < n; i++) {
        // If frequency of a
        // particular element
        // exceeds K
        if (freq[a[i]] + 1 > k) {
            // Not possible
            console.log (-1);
            return;
        }
 
        // Increase the frequency
        if (!freq.hasOwnProperty(a[i]))
            freq[a[i]] = 0
        freq[a[i]] += 1;
         
        // Store the element for the
        // respective set
        if (!ans.hasOwnProperty(freq[a[i]]))
            ans[freq[a[i]]] = []
        ans[freq[a[i]]].push(a[i]);
    }
 
    // Display the sets
    for (var [k, it] of Object.entries(ans)) {
        console.log("(", it.join(" "), ")")
    }
}
 
 
// Driver code
let arr = [ 2, 1, 2, 3, 1, 4, 1, 3, 1, 4 ];
let n = arr.length;
let k = 4;
splitSets(arr, n, k);
 
// This code is contributed by phasing17


Output: 

( 2 1 3 4 )
( 2 1 3 4 )
( 1 )
( 1 )

 

Time complexity: O(nlogn) since using a for loop

Auxiliary Space: O(n)



Last Updated : 19 Sep, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads