Skip to content
Related Articles

Related Articles

Improve Article
Equally divide into two sets such that one set has maximum distinct elements
  • Difficulty Level : Easy
  • Last Updated : 28 May, 2021

There are two processes P1 and P2, and N resources where N is an even number. There is an array of N size and arr[i] represents the type of ith resource.There may be more then one instance of a resource.You are to divide these resources equally between P1 and P2 such that maximum number of distinct number of resources are allocated to P2. Print maximum number of distinct resources allocated to P2.

Examples: 

Input : arr[] = [1, 1, 2, 2, 3, 3] 
Output: 3 
Explanation: 
There are three different kinds of resources (1, 2 and 3), and two for each kind. Optimal distribution: Process P1 has resources [1, 2, 3] and the process P2 has gifts [1, 2, 3], too. Process p2 has 3 distinct resources.

Input: arr[] = [1, 1, 2, 1, 3, 4] 
Output: 3 
Explanation: 
There are three different kinds of resources (1, 2, 3, 4), 3 instances of 1 and single single instances of resource 2, 3, 4. Optimal distribution: Process P1 has resources [1, 1, 1] and the process P2 has gifts [2, 3, 4]. 
Process p2 has 3 distinct resources. 
 

Approach 1 (Using sorting): 



  1. Sort the Array of resources.
  2. Find out the elements which are unique by comparing the adjacent elements of the sorted array.suppose count holds the distinct number of resources in array.
  3. Return the minimum of count and N/2.

Below is the implementation of the above approach:

C++




// C++ program to equally divide n elements
// into two sets such that second set has
// maximum distinct elements.
#include <algorithm>
#include <iostream>
using namespace std;
 
int distribution(int arr[], int n)
{
    sort(arr, arr + n);
    int count = 1;
    for (int i = 1; i < n; i++)
        if (arr[i] > arr[i - 1])
            count++;
     
    return min(count, n / 2);
}
 
// Driver code
int main()
{
    int arr[] = { 1, 1, 2, 1, 3, 4 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << distribution(arr, n) << endl;
    return 0;
}
Java



// Java program to equally divide n elements
// into two sets such that second set has
// maximum distinct elements.
import java.util.*;
class Geeks {
     
static int distribution(int arr[], int n)
{
    Arrays.sort(arr);
    int count = 1;
    for (int i = 1; i < n; i++)
        if (arr[i] > arr[i - 1])
            count++;
     
    return Math.min(count, n / 2);
}
 
// Driver code
public static void main(String args[])
{
    int arr[] = { 1, 1, 2, 1, 3, 4 };
    int n = arr.length;
    System.out.println(distribution(arr, n));
}
}
 
// This code is contributed by ankita_saini
Python3



# Python 3 program to equally divide n
# elements into two sets such that second
# set has maximum distinct elements.
 
def distribution(arr, n):
    arr.sort(reverse = False)
    count = 1
    for i in range(1, n, 1):
        if (arr[i] > arr[i - 1]):
            count += 1
     
    return min(count, n / 2)
 
# Driver code
if __name__ == '__main__':
    arr = [1, 1, 2, 1, 3, 4]
    n = len(arr)
    print(int(distribution(arr, n)))
 
# This code is contributed by
# Shashank_Sharma
C#



// C# program to equally divide
// n elements into two sets such
// that second set has maximum
// distinct elements.
using System;
 
class GFG
{
static int distribution(int []arr, int n)
{
    Array.Sort(arr);
    int count = 1;
    for (int i = 1; i < n; i++)
        if (arr[i] > arr[i - 1])
            count++;
     
    return Math.Min(count, n / 2);
}
 
// Driver code
public static void Main(String []args)
{
    int []arr= { 1, 1, 2, 1, 3, 4 };
    int n = arr.Length;
    Console.WriteLine(distribution(arr, n));
}
}
 
// This code is contributed
// by ankita_saini
PHP



<?php
// PHP program to equally divide n elements
// into two sets such that second set has
// maximum distinct elements.
 
function distribution($arr, $n)
{
    sort($arr);
    $count = 1;
    for ($i = 1; $i <$n; $i++)
        if ($arr[$i] > $arr[$i - 1])
            $count++;
     
    return min($count, $n / 2);
}
 
// Driver code
$arr = array(1, 1, 2, 1, 3, 4 );
$n = count($arr);
echo(distribution($arr, $n));
 
// This code is contributed
// by inder_verma
?>
Javascript



<script>
 
// Javascript program to equally divide n elements
// into two sets such that second set has
// maximum distinct elements.
 
function distribution(arr, n)
{
    arr.sort((a,b)=>a-b);
    var count = 1;
    for (var i = 1; i < n; i++)
        if (arr[i] > arr[i - 1])
            count++;
     
    return Math.min(count, parseInt(n / 2));
}
 
// Driver code
var arr = [1, 1, 2, 1, 3, 4];
var n = arr.length;
document.write( distribution(arr, n));
 
</script>
Output: 
3
Time complexity– O(N log N)
Approach 2(using hash set) 
Another way to find out distinct element is set, insert all the element in the set. By the property of a set, it will contain only unique elements. At the end, we can count the number of elements in the set, given by, say count. The value to be returned will again be given by min(count, n/2).
C++



// C++ program to equally divide n elements
// into two sets such that second set has
// maximum distinct elements.
#include <bits/stdc++.h>
using namespace std;
 
int distribution(int arr[], int n)
{
    set<int, greater<int> > resources;
 
    // Insert all the resources in the set
    // There will be unique resources in the set
    for (int i = 0; i < n; i++)
        resources.insert(arr[i]);   
 
    // return minimum of distinct resources
    // and n/2
      int m = resources.size();
    return min(m, n / 2);
}
 
// Driver code
int main()
{
    int arr[] = { 1, 1, 2, 1, 3, 4 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << distribution(arr, n) << endl;
    return 0;
}
Java



// Java program to equally divide n elements
// into two sets such that second set has
// maximum distinct elements.
import java.util.*;
 
class GFG
{
 
static int distribution(int arr[], int n)
{
    Set<Integer> resources = new HashSet<Integer>();
 
    // Insert all the resources in the set
    // There will be unique resources in the set
    for (int i = 0; i < n; i++)
        resources.add(arr[i]);
 
    // return minimum of distinct resources
    // and n/2
    return Math.min(resources.size(), n / 2);
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 1, 1, 2, 1, 3, 4 };
    int n = arr.length;
    System.out.print(distribution(arr, n) +"\n");
}
}
 
// This code is contributed by Rajput-Ji
Python3



# Python3 program to equally divide n elements
# into two sets such that second set has
# maximum distinct elements.
def distribution(arr, n):
    resources = set()
     
    # Insert all the resources in the set
    # There will be unique resources in the set
    for i in range(n):
        resources.add(arr[i]);
 
        # return minimum of distinct resources
        # and n/2
    return min(len(resources), n // 2);
 
# Driver code
if __name__ == '__main__':
    arr = [ 1, 1, 2, 1, 3, 4 ];
    n = len(arr);
    print(distribution(arr, n), "");
     
# This code is contributed by PrinciRaj1992
C#



// C# program to equally divide n elements
// into two sets such that second set has
// maximum distinct elements.
using System;
using System.Collections.Generic;
 
class GFG
{
 
static int distribution(int []arr, int n)
{
    HashSet<int> resources = new HashSet<int>();
 
    // Insert all the resources in the set
    // There will be unique resources in the set
    for (int i = 0; i < n; i++)
        resources.Add(arr[i]);
 
    // return minimum of distinct resources
    // and n/2
    return Math.Min(resources.Count, n / 2);
}
 
// Driver code
public static void Main(String[] args)
{
    int []arr = { 1, 1, 2, 1, 3, 4 };
    int n = arr.Length;
    Console.Write(distribution(arr, n) +"\n");
}
}
 
// This code is contributed by PrinciRaj1992
Output
3
 
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
In case you wish to attend live classes with industry experts, please refer Geeks Classes Live 



My Personal Notes
arrow_drop_up
Next

Check if a pair with given product exists in Linked list
Recommended Articles
Page :
Split an array containing N elements into K sets of distinct elements
31, May 20
Maximum number of elements greater than X after equally distributing subset of array
20, Jun 20
Maximum number of chocolates to be distributed equally among k students
25, Dec 17
Ways to divide a binary array into sub-arrays such that each sub-array contains exactly one 1
28, Jan 19
Number of K's such that the given array can be divided into two sets satisfying the given conditions
29, Oct 19
Divide N segments into two non-empty groups such that given condition is satisfied
21, Jan 19
Divide array into two sub-arrays such that their averages are equal
27, Jan 17
Minimum positive integer required to split the array equally
09, Jul 18
Count of arrays in which all adjacent elements are such that one of them divide the another
02, May 17
Minimum number of segments required such that each segment has distinct elements
29, Oct 18
Maximum sum in an array such that every element has exactly one adjacent element to it
23, May 19
Divide array in two Subsets such that sum of square of sum of both subsets is maximum
07, Feb 20
Partition a set into two subsets such that difference between max of one and min of other is minimized
16, Jun 20
Split array into maximum subarrays such that every distinct element lies in a single subarray
27, Sep 20
Maximum value K such that array has at-least K elements that are >= K
23, Jun 16
Divide array in two maximum equal length arrays of similar and dissimilar elements
30, Apr 20
Number of sub-sequence such that it has one consecutive element with difference less than or equal to 1
11, Jun 19
Divide an array into k segments to maximize maximum of segment minimums
19, Oct 17
Divide array into two parts with equal sum according to the given constraints
09, Apr 19
Count number of ways to divide an array into two halves with same sum
24, May 19
Divide array into two arrays which does not contain any pair with sum K
03, Nov 20
Check if a string can be split into 3 substrings such that one of them is a substring of the other two
05, Apr 21
Divide every element of one array by other array elements
28, Oct 17
Divide the array into minimum number of sub-arrays having unique elements
21, Oct 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Yogesh Shukla 1
@Yogesh Shukla 1
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox