# Minimum number of subsets with distinct elements

Last Updated : 13 Dec, 2023

You are given an array of n-element. You have to make subsets from the array such that no subset contain duplicate elements. Find out minimum number of subset possible.

Examples :

`Input : arr[] = {1, 2, 3, 4}Output :1Explanation : A single subset can contains all values and all values are distinctInput : arr[] = {1, 2, 3, 3}Output : 2Explanation : We need to create two subsets{1, 2, 3} and {3} [or {1, 3} and {2, 3}] suchthat both subsets have distinct elements.`

We basically need to find the most frequent element in the array. The result is equal to the frequency of the most frequent element. Since we have to create a subset such that each element in a subset is unique that means that all the repeating elements should be kept in a different set. Hence the maximum no subsites that we require is the frequency of the maximum time occurring element.

Ex -> { 1 , 2 , 1 , 2 , 3 , 3 , 2 , 2 }
here
Frequency of 1 -> 2
Frequency of 2 -> 4
Frequency of 3 -> 2

Since the frequency of 2 is maximum hence we need to have at least 4 subset to keep all the 2 in different subsets and rest of element can be occupied accordingly.

A simple solution is to run two nested loops to count frequency of every element and return the frequency of the most frequent element. Time complexity of this solution is O(n2).

A better solution is to first sort the array and then start count number of repetitions of elements in an iterative manner as all repetition of any number lie beside the number itself. By this method you can find the maximum frequency or repetition by simply traversing the sorted array. This approach will cost O(nlogn) time complexity

Implementation:

## C++

 `// A sorting based solution to find the ` `// minimum number of subsets of a set ` `// such that every subset contains distinct` `// elements.` `#include ` `using` `namespace` `std;`   `// Function to count subsets such that all` `// subsets have distinct elements.` `int` `subset(``int` `ar[], ``int` `n)` `{` `    ``// Take input and initialize res = 0` `    ``int` `res = 0;`   `    ``// Sort the array` `    ``sort(ar, ar + n);`   `    ``// Traverse the input array and` `    ``// find maximum frequency` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``int` `count = 1;`   `        ``// For each number find its repetition / frequency` `        ``for` `(; i < n - 1; i++) {` `            ``if` `(ar[i] == ar[i + 1])` `                ``count++;` `            ``else` `                ``break``;` `        ``}`   `        ``// Update res` `        ``res = max(res, count);` `    ``}`   `    ``return` `res;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 5, 6, 9, 3, 4, 3, 4 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``cout << subset(arr, n);` `    ``return` `0;` `}`

## Java

 `// A sorting based solution to find the ` `// minimum number of subsets of a set ` `// such that every subset contains distinct` `// elements.` `import` `java.util.*;` `import` `java.lang.*;`   `public` `class` `GfG{` `    `  `    ``// Function to count subsets such that all` `    ``// subsets have distinct elements.` `    ``public` `static` `int` `subset(``int` `ar[], ``int` `n)` `    ``{` `        ``// Take input and initialize res = 0` `        ``int` `res = ``0``;`   `        ``// Sort the array` `        ``Arrays.sort(ar);`   `        ``// Traverse the input array and` `        ``// find maximum frequency` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``int` `count = ``1``;`   `            ``// For each number find its repetition / frequency` `            ``for` `(; i < n - ``1``; i++) {` `                ``if` `(ar[i] == ar[i + ``1``])` `                    ``count++;` `                ``else` `                    ``break``;` `            ``}`   `            ``// Update res` `            ``res = Math.max(res, count);` `        ``}`   `        ``return` `res;` `    ``}` `    `  `    ``// Driver function` `    ``public` `static` `void` `main(String argc[])` `    ``{` `        ``int` `arr[] = { ``5``, ``6``, ``9``, ``3``, ``4``, ``3``, ``4` `};` `        ``int` `n = ``7``;` `        ``System.out.println(subset(arr, n));` `    ``}` `    `  `}`   `/* This code is contributed by Sagar Shukla */`

## Python3

 `# A sorting based solution to find the ` `# minimum number of subsets of a set ` `# such that every subset contains distinct` `# elements.`   `# function to count subsets such that all` `# subsets have distinct elements.` `def` `subset(ar, n):`   `    ``# take input and initialize res = 0` `    ``res ``=` `0`   `    ``# sort the array` `    ``ar.sort()`   `    ``# traverse the input array and` `    ``# find maximum frequency` `    ``for` `i ``in` `range``(``0``, n) :` `        ``count ``=` `1`   `        ``# for each number find its repetition / frequency` `        ``for` `i ``in` `range``(n ``-` `1``):` `            ``if` `ar[i] ``=``=` `ar[i ``+` `1``]:` `                ``count``+``=``1` `            ``else``:` `                ``break` `            `  `        ``# update res` `        ``res ``=` `max``(res, count)` `    `  `    ``return` `res`     `# Driver code` `ar ``=` `[ ``5``, ``6``, ``9``, ``3``, ``4``, ``3``, ``4` `]` `n ``=` `len``(ar)` `print``(subset(ar, n))`   `# This code is contributed by` `# Smitha Dinesh Semwal`

## C#

 `// A sorting based solution to find the ` `// minimum number of subsets of a set ` `// such that every subset contains distinct` `// elements.` `using` `System;`   `public` `class` `GfG {` `    `  `    ``// Function to count subsets such that all` `    ``// subsets have distinct elements.` `    ``public` `static` `int` `subset(``int` `[]ar, ``int` `n)` `    ``{` `        ``// Take input and initialize res = 0` `        ``int` `res = 0;`   `        ``// Sort the array` `        ``Array.Sort(ar);`   `        ``// Traverse the input array and` `        ``// find maximum frequency` `        ``for` `(``int` `i = 0; i < n; i++) {` `            ``int` `count = 1;`   `            ``// For each number find its ` `            ``// repetition / frequency` `            ``for` `( ; i < n - 1; i++) {` `                ``if` `(ar[i] == ar[i + 1])` `                    ``count++;` `                ``else` `                    ``break``;` `            ``}`   `            ``// Update res` `            ``res = Math.Max(res, count);` `        ``}`   `        ``return` `res;` `    ``}` `    `  `    ``// Driver function` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `[]arr = { 5, 6, 9, 3, 4, 3, 4 };` `        ``int` `n = 7;` `        `  `        ``Console.WriteLine(subset(arr, n));` `    ``}` `    `  `}`   `/* This code is contributed by Vt_m */`

## Javascript

 ``

## PHP

 ``

Output

```2

```

Time Complexity: O(n2)
Auxiliary Space: O(1)

An efficient solution is to use hashing. We count frequencies of all elements in a hash table. Finally we return the key with maximum value in hash table.

Implementation:

## C++

 `// A hashing based solution to find the ` `// minimum number of subsets of a set ` `// such that every subset contains distinct` `// elements.` `#include ` `using` `namespace` `std;`   `// Function to count subsets such that all` `// subsets have distinct elements.` `int` `subset(``int` `arr[], ``int` `n)` `{   ` `    ``// Traverse the input array and` `    ``// store frequencies of elements` `    ``unordered_map<``int``, ``int``> mp;    ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``mp[arr[i]]++;` `    `  `    ``// Find the maximum value in map.` `    ``int` `res = 0;` `    ``for` `(``auto` `x : mp)` `       ``res = max(res, x.second);`   `    ``return` `res;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 5, 6, 9, 3, 4, 3, 4 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``cout << subset(arr, n);` `    ``return` `0;` `}`

## Java

 `import` `java.util.HashMap;` `import` `java.util.Map;`   `// A hashing based solution to find the ` `// minimum number of subsets of a set ` `// such that every subset contains distinct` `// elements.` `class` `GFG ` `{ ` `    `  `// Function to count subsets such that all` `// subsets have distinct elements.` `static` `int` `subset(``int` `arr[], ``int` `n)` `{ ` `    ``// Traverse the input array and` `    ``// store frequencies of elements` `    ``HashMap mp = ``new` `HashMap<>(); ` `    ``for` `(``int` `i = ``0``; i < n; i++) ` `        ``mp.put(arr[i],mp.get(arr[i]) == ``null``?``1``:mp.get(arr[i])+``1``);` `    `  `    ``// Find the maximum value in map.` `    ``int` `res = ``0``;` `    ``for` `(Map.Entry entry : mp.entrySet()) ` `    ``res = Math.max(res, entry.getValue());`   `    ``return` `res;` `}`   `// Driver code` `public` `static` `void` `main(String[] args) ` `{` `    ``int` `arr[] = { ``5``, ``6``, ``9``, ``3``, ``4``, ``3``, ``4` `};` `    ``int` `n = arr.length;` `    ``System.out.println( subset(arr, n));`   `}` `}`   `// This code is contributed by Rajput-Ji`

## Python3

 `# A hashing based solution to find the ` `# minimum number of subsets of a set such  ` `# that every subset contains distinct` `# elements.`   `# Function to count subsets such that ` `# all subsets have distinct elements.` `def` `subset(arr, n):` `    `  `    ``# Traverse the input array and` `    ``# store frequencies of elements` `    ``mp ``=` `{i:``0` `for` `i ``in` `range``(``10``)}` `    ``for` `i ``in` `range``(n):` `        ``mp[arr[i]] ``+``=` `1` `    `  `    ``# Find the maximum value in map.` `    ``res ``=` `0` `    ``for` `key, value ``in` `mp.items():` `        ``res ``=` `max``(res, value)`   `    ``return` `res`   `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    ``arr ``=` `[``5``, ``6``, ``9``, ``3``, ``4``, ``3``, ``4``]` `    ``n ``=` `len``(arr)` `    ``print``(subset(arr, n))`   `# This code is contributed by` `# Surendra_Gangwar`

## C#

 `// A hashing based solution to find the ` `// minimum number of subsets of a set ` `// such that every subset contains distinct` `// elements.` `using` `System;` `using` `System.Collections.Generic; `   `class` `GFG ` `{ ` `    `  `// Function to count subsets such that all` `// subsets have distinct elements.` `static` `int` `subset(``int` `[]arr, ``int` `n)` `{ ` `    ``// Traverse the input array and` `    ``// store frequencies of elements` `    ``Dictionary<``int``, ` `               ``int``> mp = ``new` `Dictionary<``int``, ` `                                        ``int``>();` `    ``for` `(``int` `i = 0 ; i < n; i++)` `    ``{` `        ``if``(mp.ContainsKey(arr[i]))` `        ``{` `            ``var` `val = mp[arr[i]];` `            ``mp.Remove(arr[i]);` `            ``mp.Add(arr[i], val + 1); ` `        ``}` `        ``else` `        ``{` `            ``mp.Add(arr[i], 1);` `        ``}` `    ``}` `    `  `    ``// Find the maximum value in map.` `    ``int` `res = 0;` `    ``foreach``(KeyValuePair<``int``, ``int``> entry ``in` `mp)` `        ``res = Math.Max(res, entry.Value);`   `    ``return` `res;` `}`   `// Driver code` `public` `static` `void` `Main(String[] args) ` `{` `    ``int` `[]arr = { 5, 6, 9, 3, 4, 3, 4 };` `    ``int` `n = arr.Length;` `    ``Console.WriteLine(subset(arr, n));` `}` `}`   `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output

```2

```

Time Complexity: O(n)
Auxiliary Space: O(n)

Example in c:

Approach:

Initialize a hash set to store distinct elements and a variable, count, to zero.

Iterate over all elements of the array.

For each element, check if it is already present in the hash set using the following conditions:

If the element is not present, add it to the hash set.
If the element is present, increment the count and reset the hash set.
Finally, return the count.

## C++

 `// C++ code for the above approach` `#include `   `using` `namespace` `std;`   `struct` `node {` `    ``int` `data;` `    ``struct` `node* next;` `};`   `struct` `node* create_node(``int` `data) {` `    ``struct` `node* new_node = (``struct` `node*) ``malloc``(``sizeof``(``struct` `node));` `    ``new_node->data = data;` `    ``new_node->next = NULL;` `    ``return` `new_node;` `}`   `struct` `set {` `    ``struct` `node* head;` `};`   `struct` `set* create_set() {` `    ``struct` `set* new_set = (``struct` `set*) ``malloc``(``sizeof``(``struct` `set));` `    ``new_set->head = NULL;` `    ``return` `new_set;` `}`   `void` `add_to_set(``struct` `set* set, ``int` `data) {` `    ``if` `(set->head == NULL) {` `        ``set->head = create_node(data);` `        ``return``;` `    ``}`   `    ``struct` `node* current = set->head;` `    ``while` `(current != NULL) {` `        ``if` `(current->data == data) {` `            ``return``;` `        ``}` `        ``current = current->next;` `    ``}`   `    ``struct` `node* new_node = create_node(data);` `    ``new_node->next = set->head;` `    ``set->head = new_node;` `}`   `void` `delete_set(``struct` `set* set) {` `    ``struct` `node* current = set->head;` `    ``while` `(current != NULL) {` `        ``struct` `node* temp = current;` `        ``current = current->next;` `        ``free``(temp);` `    ``}` `    ``free``(set);` `}`   `int` `count_min_subsets_with_distinct_elements(``int` `arr[], ``int` `n) {` `    ``struct` `set* set = create_set();` `    ``int` `count = 0;`   `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``if` `(set->head == NULL || !(set, arr[i])) {` `            ``add_to_set(set, arr[i]);` `        ``} ``else` `{` `            ``count++;` `            ``delete_set(set);` `            ``set = create_set();` `            ``add_to_set(set, arr[i]);` `        ``}` `    ``}`   `    ``delete_set(set);`   `    ``if` `(count == 0) {` `        ``return` `1;` `    ``} ``else` `{` `        ``return` `count + 1;` `    ``}` `}`   `int` `main() {` `    ``int` `arr[] = {1, 2, 3, 1, 2, 3, 4, 5};` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``cout << ``"Minimum number of subsets with distinct elements: "` `<< count_min_subsets_with_distinct_elements(arr, n) << endl;` `    ``return` `0;` `}`   `// Contributed by adityasharmadev01`

## C

 `#include ` `#include `   `struct` `node {` `    ``int` `data;` `    ``struct` `node *next;` `};`   `struct` `node* create_node(``int` `data) {` `    ``struct` `node* new_node = (``struct` `node*) ``malloc``(``sizeof``(``struct` `node));` `    ``new_node->data = data;` `    ``new_node->next = NULL;` `    ``return` `new_node;` `}`   `struct` `set {` `    ``struct` `node *head;` `};`   `struct` `set* create_set() {` `    ``struct` `set* new_set = (``struct` `set*) ``malloc``(``sizeof``(``struct` `set));` `    ``new_set->head = NULL;` `    ``return` `new_set;` `}`   `void` `add_to_set(``struct` `set *set, ``int` `data) {` `    ``if` `(set->head == NULL) {` `        ``set->head = create_node(data);` `        ``return``;` `    ``}`   `    ``struct` `node *current = set->head;` `    ``while` `(current != NULL) {` `        ``if` `(current->data == data) {` `            ``return``;` `        ``}` `        ``current = current->next;` `    ``}`   `    ``struct` `node *new_node = create_node(data);` `    ``new_node->next = set->head;` `    ``set->head = new_node;` `}`   `void` `delete_set(``struct` `set *set) {` `    ``struct` `node *current = set->head;` `    ``while` `(current != NULL) {` `        ``struct` `node *temp = current;` `        ``current = current->next;` `        ``free``(temp);` `    ``}` `    ``free``(set);` `}`   `int` `count_min_subsets_with_distinct_elements(``int` `arr[], ``int` `n) {` `    ``struct` `set *set = create_set();` `    ``int` `count = 0;`   `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``if` `(set->head == NULL || !(set, arr[i])) {` `            ``add_to_set(set, arr[i]);` `        ``} ``else` `{` `            ``count++;` `            ``delete_set(set);` `            ``set = create_set();` `            ``add_to_set(set, arr[i]);` `        ``}` `    ``}`   `    ``delete_set(set);`   `    ``if` `(count == 0) {` `        ``return` `1;` `    ``} ``else` `{` `        ``return` `count + 1;` `    ``}` `}`   `int` `main() {` `    ``int` `arr[] = {1, 2, 3, 1, 2, 3, 4, 5};` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``printf``(``"Minimum number of subsets with distinct elements: %d\n"``, count_min_subsets_with_distinct_elements(arr, n));` `    ``return` `0;` `}`

## Java

 `import` `java.util.HashSet;` `import` `java.util.Set;`   `public` `class` `Main {` `    ``// Function to find the minimum number of subsets with` `    ``// distinct elements` `    ``public` `static` `int` `    ``minSubsetsWithDistinctElements(``int``[] arr)` `    ``{` `        ``Set uniqueElements = ``new` `HashSet<>();` `        ``int` `count = ``0``; ``// Counter to keep track of subsets` `                       ``// with distinct elements`   `        ``for` `(``int` `i = ``0``; i < arr.length; i++) {` `            ``if` `(!uniqueElements.contains(arr[i])) {` `                ``// If the element is not in the set, add it` `                ``// to the set` `                ``uniqueElements.add(arr[i]);` `            ``}` `            ``else` `{` `                ``// If the element is already in the set,` `                ``// it's a duplicate, so we:` `                ``// 1. Increase the count by the size of the` `                ``// current set (distinct elements)` `                ``count += uniqueElements.size();` `                ``// 2. Clear the set to start counting the` `                ``// next subset of distinct elements` `                ``uniqueElements.clear();` `                ``// 3. Add the current element to the cleared` `                ``// set to continue counting` `                ``uniqueElements.add(arr[i]);` `            ``}` `        ``}`   `        ``// After the loop, add any remaining distinct` `        ``// elements in the last subset` `        ``return` `count + uniqueElements.size();` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int``[] arr = { ``1``, ``2``, ``3``, ``1``, ``2``, ``3``, ``4``, ``5` `};` `        ``int` `result = minSubsetsWithDistinctElements(arr);` `        ``System.out.println(` `            ``"Minimum number of subsets with distinct elements: "` `            ``+ result);` `    ``}` `}`

## Python

 `# Function to find the minimum number of subsets with distinct elements` `def` `min_subsets_with_distinct_elements(arr):` `    ``unique_elements ``=` `set``()` `    ``count ``=` `0`  `# Counter to keep track of subsets with distinct elements`   `    ``for` `element ``in` `arr:` `        ``if` `element ``not` `in` `unique_elements:` `            ``# If the element is not in the set, add it to the set` `            ``unique_elements.add(element)` `        ``else``:` `            ``# If the element is already in the set, it's a duplicate, so we:` `            ``# 1. Increase the count by the size of the current set (distinct elements)` `            ``count ``+``=` `len``(unique_elements)` `            ``# 2. Clear the set to start counting the next subset of distinct elements` `            ``unique_elements.clear()` `            ``# 3. Add the current element to the cleared set to continue counting` `            ``unique_elements.add(element)`   `    ``# After the loop, add any remaining distinct elements in the last subset` `    ``return` `count ``+` `len``(unique_elements)`     `# Main function` `if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``1``, ``2``, ``3``, ``1``, ``2``, ``3``, ``4``, ``5``]` `    ``result ``=` `min_subsets_with_distinct_elements(arr)` `    ``print``(``"Minimum number of subsets with distinct elements:"``, result)`

## C#

 `using` `System;`   `public` `class` `Program {` `    ``public` `class` `Node {` `        ``public` `int` `data;` `        ``public` `Node next;` `    ``}`   `    ``public` `static` `Node create_node(``int` `data) {` `        ``Node new_node = ``new` `Node();` `        ``new_node.data = data;` `        ``new_node.next = ``null``;` `        ``return` `new_node;` `    ``}`   `    ``public` `class` `Set {` `        ``public` `Node head;` `    ``}`   `    ``public` `static` `Set create_set() {` `        ``Set new_set = ``new` `Set();` `        ``new_set.head = ``null``;` `        ``return` `new_set;` `    ``}`   `    ``public` `static` `void` `add_to_set(Set ``set``, ``int` `data) {` `        ``if` `(``set``.head == ``null``) {` `            ``set``.head = create_node(data);` `            ``return``;` `        ``}` `        ``Node current = ``set``.head;` `        ``while` `(current != ``null``) {` `            ``if` `(current.data == data) {` `                ``return``;` `            ``}` `            ``current = current.next;` `        ``}` `        ``Node new_node = create_node(data);` `        ``new_node.next = ``set``.head;` `        ``set``.head = new_node;` `    ``}`   `    ``public` `static` `void` `delete_set(Set ``set``) {` `        ``Node current = ``set``.head;` `        ``while` `(current != ``null``) {` `            ``Node temp = current;` `            ``current = current.next;` `            ``temp = ``null``;` `        ``}` `        ``set``.head = ``null``;` `    ``}`   `    ``public` `static` `int` `count_min_subsets_with_distinct_elements(``int``[] arr, ``int` `n) {` `        ``Set ``set` `= create_set();` `        ``int` `count = 0;` `        ``for` `(``int` `i = 0; i < n; i++) {` `            ``if` `(``set``.head == ``null` `|| !set_has(``set``, arr[i])) {` `                ``add_to_set(``set``, arr[i]);` `            ``} ``else` `{` `                ``count++;` `                ``delete_set(``set``);` `                ``set` `= create_set();` `                ``add_to_set(``set``, arr[i]);` `            ``}` `        ``}` `        ``delete_set(``set``);` `        ``if` `(count == 0) {` `            ``return` `1;` `        ``} ``else` `{` `            ``return` `count + 1;` `        ``}` `    ``}`   `    ``public` `static` `bool` `set_has(Set ``set``, ``int` `data) {` `        ``Node current = ``set``.head;` `        ``while` `(current != ``null``) {` `            ``if` `(current.data == data) {` `                ``return` `true``;` `            ``}` `            ``current = current.next;` `        ``}` `        ``return` `false``;` `    ``}`   `    ``public` `static` `void` `Main() {` `        ``int``[] arr = {1, 2, 3, 1, 2, 3, 4, 5};` `        ``int` `n = arr.Length;` `        ``Console.WriteLine(``"Minimum number of subsets with distinct elements: "` `+ count_min_subsets_with_distinct_elements(arr, n));` `    ``}` `}` `// This code is contributed by shiv1o43g`

## Javascript

 `function` `GFG(arr) {` `    ``let uniqueElements = ``new` `Set();` `    ``let count = 0;` `    ``for` `(let i = 0; i < arr.length; i++) {` `        ``if` `(!uniqueElements.has(arr[i])) {` `            ``uniqueElements.add(arr[i]);` `        ``} ``else` `{` `            ``count += uniqueElements.size;` `            ``uniqueElements.clear();` `            ``uniqueElements.add(arr[i]);` `        ``}` `    ``}` `    ``return` `count + uniqueElements.size;` `}` `const arr = [1, 2, 3, 1, 2, 3, 4, 5];` `const result = GFG(arr);` `console.log(``"Minimum number of subsets with distinct elements:"``, result);`

Output

```Minimum number of subsets with distinct elements: 8

```

The time complexity of this approach is O(n^2) since we use a loop within a loop to check for distinct elements.

The space complexity is O(n) since we use a hash set to store distinct elements.

Approach:

At first, Initialize a DP array of size n, where n is the length of the input array. Now, we know dp[i] represents the minimum number of subsets required up to the i-th element of the given array.
Initialize a set to keep track of distinct elements seen so far. This set will be used to check for duplicate elements.
Initialize dp[0] as 1, since the first element itself forms a subset. Iterate through the array starting from the second element (i = 1) to the last element (i = n-1):Check if the current element is already present in the set.
If it is not present, add it to the set and set dp[i] = dp[i-1].
If it is present, increment dp[i] by 1 to account for a new subset required.
Clear the set and add the current element to start a new subset.
The final answer will be dp[n-1], representing the minimum number of subsets required to cover all the distinct elements.

## C++

 `#include ` `#include ` `using` `namespace` `std;`   `int` `GFG(``int` `arr[], ``int` `n) {` `    ``int` `dp[n];` `    ``// Using an unordered_set to track distinct elements` `    ``unordered_set<``int``> distinctElements;   ` `    ``dp[0] = 1;` `    ``distinctElements.insert(arr[0]);` `    ``for` `(``int` `i = 1; i < n; i++) {` `        ``if` `(distinctElements.find(arr[i]) == distinctElements.end()) {` `            ``// If the element is not in the set` `            ``// add it and continue with previous subset count` `            ``distinctElements.insert(arr[i]);` `            ``dp[i] = dp[i - 1];` `        ``} ``else` `{` `            ``// If the element is already in the set` `            ``// start a new subset and clear the set` `            ``dp[i] = dp[i - 1] + 1;` `            ``distinctElements.clear();` `            ``distinctElements.insert(arr[i]);` `        ``}` `    ``}` `    ``return` `dp[n - 1];` `}` `int` `main() {` `    ``int` `arr[] = {1, 2, 3, 4};` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``int` `minSubsets = GFG(arr, n);` `    ``cout << ``"Minimum number of subsets: "` `<< minSubsets << endl;` `    ``int` `arr2[] = {1, 2, 3, 3};` `    ``int` `n2 = ``sizeof``(arr2) / ``sizeof``(arr2[0]);` `    ``minSubsets = GFG(arr2, n2);` `    ``cout << ``"Minimum number of subsets: "` `<< minSubsets << endl;` `    ``return` `0;` `}`

## Java

 `/*package whatever //do not write package name here */`   `import` `java.io.*;` `import` `java.util.HashSet;` `import` `java.util.Set;`   `class` `GFG {` `    ``public` `static` `int` `minSubsetsDistinctElements(``int``[] arr) {` `        ``int` `n = arr.length;` `        ``int``[] dp = ``new` `int``[n];`   `        ``Set distinctElements = ``new` `HashSet<>();` `        ``dp[``0``] = ``1``;` `        ``distinctElements.add(arr[``0``]);`   `        ``for` `(``int` `i = ``1``; i < n; i++) {` `            ``if` `(!distinctElements.contains(arr[i])) {` `                ``distinctElements.add(arr[i]);` `                ``dp[i] = dp[i - ``1``];` `            ``} ``else` `{` `                ``dp[i] = dp[i - ``1``] + ``1``;` `                ``distinctElements.clear();` `                ``distinctElements.add(arr[i]);` `            ``}` `        ``}`   `        ``return` `dp[n - ``1``];` `    ``}`   `    ``public` `static` `void` `main(String[] args) {` `        ``int``[] arr = {``1``, ``2``, ``3``, ``4``};` `        ``int` `minSubsets = minSubsetsDistinctElements(arr);` `        ``System.out.println(``"Minimum number of subsets: "` `+ minSubsets);`   `        ``arr = ``new` `int``[]{``1``, ``2``, ``3``, ``3``};` `        ``minSubsets = minSubsetsDistinctElements(arr);` `        ``System.out.println(``"Minimum number of subsets: "` `+ minSubsets);` `    ``}` `}`   `//This code is contributed by Sovi`

## Python3

 `def` `minSubsetsDistinctElements(arr):` `    ``n ``=` `len``(arr)` `    ``dp ``=` `[``0``] ``*` `n  ``# Create an array to store the minimum subset count for each element`   `    ``distinctElements ``=` `set``()  ``# Create a set to store distinct elements ` `    ``dp[``0``] ``=` `1`  `# Initialize the first element with 1` `    ``distinctElements.add(arr[``0``]) `   `    ``for` `i ``in` `range``(``1``, n):  ``# Iterate through the array starting from the second element` `        ``if` `arr[i] ``not` `in` `distinctElements:  ` `            ``distinctElements.add(arr[i])  ` `            ``dp[i] ``=` `dp[i ``-` `1``]  ``# The minimum subset count ` `                               ``#remains the same as the previous element` `        ``else``:` `            ``dp[i] ``=` `dp[i ``-` `1``] ``+` `1` `            ``# Clear the set to start tracking distinct elements again` `            ``distinctElements.clear()` `             ``# Add the current element as a distinct element` `            ``distinctElements.add(arr[i]) `   `    ``return` `dp[n ``-` `1``] `   `# Driver code` `if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``1``, ``2``, ``3``, ``4``]` `    ``minSubsets ``=` `minSubsetsDistinctElements(arr)` `    ``print``(``"Minimum number of subsets:"``, minSubsets)`   `    ``arr ``=` `[``1``, ``2``, ``3``, ``3``]` `    ``minSubsets ``=` `minSubsetsDistinctElements(arr)` `    ``print``(``"Minimum number of subsets:"``, minSubsets)`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `class` `Program {` `    ``static` `int` `GFG(``int``[] arr, ``int` `n)` `    ``{` `        ``int``[] dp = ``new` `int``[n];` `        ``// Using a HashSet to track distinct elements` `        ``HashSet<``int``> distinctElements = ``new` `HashSet<``int``>();` `        ``dp[0] = 1;` `        ``distinctElements.Add(arr[0]);`   `        ``for` `(``int` `i = 1; i < n; i++) {` `            ``if` `(!distinctElements.Contains(arr[i])) {` `                ``// If the element is not in the set` `                ``// add it and continue with the previous` `                ``// subset count` `                ``distinctElements.Add(arr[i]);` `                ``dp[i] = dp[i - 1];` `            ``}` `            ``else` `{` `                ``// If the element is already in the set` `                ``// start a new subset and clear the set` `                ``dp[i] = dp[i - 1] + 1;` `                ``distinctElements.Clear();` `                ``distinctElements.Add(arr[i]);` `            ``}` `        ``}` `        ``return` `dp[n - 1];` `    ``}`   `    ``static` `void` `Main()` `    ``{` `        ``int``[] arr = { 1, 2, 3, 4 };` `        ``int` `n = arr.Length;` `        ``int` `minSubsets = GFG(arr, n);` `        ``Console.WriteLine(``"Minimum number of subsets: "` `                          ``+ minSubsets);`   `        ``int``[] arr2 = { 1, 2, 3, 3 };` `        ``int` `n2 = arr2.Length;` `        ``minSubsets = GFG(arr2, n2);` `        ``Console.WriteLine(``"Minimum number of subsets: "` `                          ``+ minSubsets);` `    ``}` `}`

## Javascript

 `// Function to calculate the minimum number of subsets with distinct elements` `function` `minSubsetsDistinctElements(arr) {` `    ``const n = arr.length;` `    ``const dp = ``new` `Array(n); ``// Create an array to store the dynamic programming values`   `    ``const distinctElements = ``new` `Set(); ``// Create a set to keep track of distinct elements` `    ``dp[0] = 1; ``// Initialize the first value in dp as 1 because there's one subset with the first element` `    ``distinctElements.add(arr[0]); ``// Add the first element to the set of distinct elements`   `    ``// Iterate through the array starting from the second element` `    ``for` `(let i = 1; i < n; i++) {` `        ``if` `(!distinctElements.has(arr[i])) {` `            ``// If the current element is not in the set of distinct elements` `            ``distinctElements.add(arr[i]); ``// Add it to the set` `            ``dp[i] = dp[i - 1]; ``// The number of subsets remains the same as the previous element` `        ``} ``else` `{` `            ``// If the current element is already in the set (not distinct)` `            ``dp[i] = dp[i - 1] + 1; ``// Increment the number of subsets` `            ``distinctElements.clear(); ``// Clear the set to start counting distinct elements for the next subset` `            ``distinctElements.add(arr[i]); ``// Add the current element to the set` `        ``}` `    ``}`   `    ``return` `dp[n - 1]; ``// Return the minimum number of subsets` `}`   `// Test cases` `const arr1 = [1, 2, 3, 4];` `const minSubsets1 = minSubsetsDistinctElements(arr1);` `console.log(``"Minimum number of subsets:"``, minSubsets1);`   `const arr2 = [1, 2, 3, 3];` `const minSubsets2 = minSubsetsDistinctElements(arr2);` `console.log(``"Minimum number of subsets:"``, minSubsets2);`

Output

```Minimum number of subsets: 1
Minimum number of subsets: 2

```

Time complexity : O(n), where n is the size of the input array.

Auxiliary Space: O(n) as we have used the DP array to store intermediate results.

Previous
Next