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 than 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 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):
- Sort the Array of resources.
- 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.
- Return the minimum of count and N/2.
Below is the implementation of the above approach:
C++
#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);
}
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
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);
}
public static void main(String args[])
{
int arr[] = { 1, 1, 2, 1, 3, 4 };
int n = arr.length;
System.out.println(distribution(arr, n));
}
}
|
Python3
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)
if __name__ == '__main__':
arr = [1, 1, 2, 1, 3, 4]
n = len(arr)
print(int(distribution(arr, n)))
|
C#
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);
}
public static void Main(String []args)
{
int []arr= { 1, 1, 2, 1, 3, 4 };
int n = arr.Length;
Console.WriteLine(distribution(arr, n));
}
}
|
PHP
<?php
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);
}
$arr = array(1, 1, 2, 1, 3, 4 );
$n = count($arr);
echo(distribution($arr, $n));
?>
|
Javascript
<script>
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));
}
var arr = [1, 1, 2, 1, 3, 4];
var n = arr.length;
document.write( distribution(arr, n));
</script>
|
Complexity Analysis:
- Time complexity: O(N log N)
- Auxiliary Space: O(1)
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).
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
int distribution(int arr[], int n)
{
set<int, greater<int> > resources;
for (int i = 0; i < n; i++)
resources.insert(arr[i]);
int m = resources.size();
return min(m, n / 2);
}
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
import java.util.*;
class GFG
{
static int distribution(int arr[], int n)
{
Set<Integer> resources = new HashSet<Integer>();
for (int i = 0; i < n; i++)
resources.add(arr[i]);
return Math.min(resources.size(), n / 2);
}
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");
}
}
|
Python3
def distribution(arr, n):
resources = set()
for i in range(n):
resources.add(arr[i]);
return min(len(resources), n // 2);
if __name__ == '__main__':
arr = [ 1, 1, 2, 1, 3, 4 ];
n = len(arr);
print(distribution(arr, n), "");
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static int distribution(int []arr, int n)
{
HashSet<int> resources = new HashSet<int>();
for (int i = 0; i < n; i++)
resources.Add(arr[i]);
return Math.Min(resources.Count, n / 2);
}
public static void Main(String[] args)
{
int []arr = { 1, 1, 2, 1, 3, 4 };
int n = arr.Length;
Console.Write(distribution(arr, n) +"\n");
}
}
|
Javascript
<script>
function distribution(arr, n)
{
let resources = new Set();
for (let i = 0; i < n; i++)
resources.add(arr[i]);
return Math.min(resources.size, parseInt(n / 2, 10));
}
let arr = [ 1, 1, 2, 1, 3, 4 ];
let n = arr.length;
document.write(distribution(arr, n) +"</br>");
</script>
|
Complexity Analysis:
- Time Complexity: O(nlogn), where n is the size of the given array
- Auxiliary Space: O(n), as extra space of size n is used to create a set