# Partition array into minimum number of equal length subsets consisting of a single distinct value

• Last Updated : 09 Jun, 2021

Given an array arr[] of size N, the task is to print the minimum count of equal length subsets the array can be partitioned into such that each subset contains only a single distinct element

Examples:

Input: arr[] = { 1, 2, 3, 4, 4, 3, 2, 1 }
Output:
Explanation:
Possible partition of the array is { {1, 1}, {2, 2}, {3, 3}, {4, 4} }.
Therefore, the required output is 4.

Input: arr[] = { 1, 1, 1, 2, 2, 2, 3, 3 }
Output:
Explanation:
Possible partition of the array is { {1}, {1}, {1}, {2}, {2}, {2}, {3}, {3} }.
Therefore, the required output is 8.

Naive Approach: The simplest approach to solve the problem is to store the frequency of each distinct array element, iterate over the range [N, 1] using the variable i, and check if the frequency of all distinct elements of the array is divisible by i or not. If found to be true, then print the value of (N / i)

Time Complexity: O(N2).
Auxiliary Space: O(N)

Efficient Approach: To optimize the above approach the idea is to use the concept of GCD. Follow the steps below to solve the problem:

• Initialize a map, say freq, to store the frequency of each distinct element of the array.
• Initialize a variable, say, FreqGCD, to store the GCD of frequency of each distinct element of the array.
• Traverse the map to find the value of FreqGCD.
• Finally, print the value of (N) % FreqGCD.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement` `// the above approach`   `#include ` `using` `namespace` `std;`   `// Function to find the minimum count of subsets` `// by partitioning the array with given conditions` `int` `CntOfSubsetsByPartitioning(``int` `arr[], ``int` `N)` `{` `    ``// Store frequency of each` `    ``// distinct element of the array` `    ``unordered_map<``int``, ``int``> freq;`   `    ``// Traverse the array` `    ``for` `(``int` `i = 0; i < N; i++) {`   `        ``// Update frequency` `        ``// of arr[i]` `        ``freq[arr[i]]++;` `    ``}`   `    ``// Stores GCD of frequency of` `    ``// each distinct element of the array` `    ``int` `freqGCD = 0;` `    ``for` `(``auto` `i : freq) {`   `        ``// Update freqGCD` `        ``freqGCD = __gcd(freqGCD, i.second);` `    ``}`   `    ``return` `(N) / freqGCD;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 1, 2, 3, 4, 4, 3, 2, 1 };` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``cout << CntOfSubsetsByPartitioning(arr, N);` `    ``return` `0;` `}`

## Java

 `// Java program to implement` `// the above approach` `import` `java.util.*;`   `class` `GFG{`   `// Function to find the minimum count of subsets` `// by partitioning the array with given conditions` `static` `int` `CntOfSubsetsByPartitioning(``int` `arr[], ``int` `N)` `{` `    ``// Store frequency of each` `    ``// distinct element of the array` `    ``HashMap freq = ``new` `HashMap<>();`   `    ``// Traverse the array` `    ``for` `(``int` `i = ``0``; i < N; i++) {`   `        ``// Update frequency` `        ``// of arr[i]` `        ``if``(freq.containsKey(arr[i])){` `            ``freq.put(arr[i], freq.get(arr[i])+``1``);` `        ``}` `        ``else``{` `            ``freq.put(arr[i], ``1``);` `        ``}` `    ``}`   `    ``// Stores GCD of frequency of` `    ``// each distinct element of the array` `    ``int` `freqGCD = ``0``;` `    ``for` `(Map.Entry i : freq.entrySet()) {`   `        ``// Update freqGCD` `        ``freqGCD = __gcd(freqGCD, i.getValue());` `    ``}`   `    ``return` `(N) / freqGCD;` `}` `  `  `// Recursive function to return gcd of a and b  ` `static` `int` `__gcd(``int` `a, ``int` `b)  ` `{  ` ` ``return` `b == ``0``? a:__gcd(b, a % b);     ` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `arr[] = { ``1``, ``2``, ``3``, ``4``, ``4``, ``3``, ``2``, ``1` `};` `    ``int` `N = arr.length;` `    ``System.out.print(CntOfSubsetsByPartitioning(arr, N));` `}` `}`   `// This code is contributed by 29AjayKumar `

## Python3

 `# Python3 program to implement` `# the above approach` `from` `math ``import` `gcd`   `# Function to find the minimum count ` `# of subsets by partitioning the array ` `# with given conditions` `def` `CntOfSubsetsByPartitioning(arr, N):` `    `  `    ``# Store frequency of each` `    ``# distinct element of the array` `    ``freq ``=` `{}`   `    ``# Traverse the array` `    ``for` `i ``in` `range``(N):` `        `  `        ``# Update frequency` `        ``# of arr[i]` `        ``freq[arr[i]] ``=` `freq.get(arr[i], ``0``) ``+` `1`   `    ``# Stores GCD of frequency of` `    ``# each distinct element of the array` `    ``freqGCD ``=` `0` `    `  `    ``for` `i ``in` `freq:` `        `  `        ``# Update freqGCD` `        ``freqGCD ``=` `gcd(freqGCD, freq[i])`   `    ``return` `(N) ``/``/` `freqGCD`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``arr ``=` `[ ``1``, ``2``, ``3``, ``4``, ``4``, ``3``, ``2``, ``1` `]` `    ``N ``=` `len``(arr)` `    `  `    ``print``(CntOfSubsetsByPartitioning(arr, N))`   `# This code is contributed by mohit kumar 29`

## C#

 `// C# program to implement` `// the above approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{`   `// Function to find the minimum count of subsets` `// by partitioning the array with given conditions` `static` `int` `CntOfSubsetsByPartitioning(``int` `[]arr, ``int` `N)` `{` `    ``// Store frequency of each` `    ``// distinct element of the array` `    ``Dictionary<``int``,``int``> freq = ``new` `Dictionary<``int``,``int``>();`   `    ``// Traverse the array` `    ``for` `(``int` `i = 0; i < N; i++) {`   `        ``// Update frequency` `        ``// of arr[i]` `        ``if``(freq.ContainsKey(arr[i])){` `            ``freq[arr[i]] = freq[arr[i]]+1;` `        ``}` `        ``else``{` `            ``freq.Add(arr[i], 1);` `        ``}` `    ``}`   `    ``// Stores GCD of frequency of` `    ``// each distinct element of the array` `    ``int` `freqGCD = 0;` `    ``foreach` `(KeyValuePair<``int``,``int``> i ``in` `freq) {`   `        ``// Update freqGCD` `        ``freqGCD = __gcd(freqGCD, i.Value);` `    ``}`   `    ``return` `(N) / freqGCD;` `}` `  `  `// Recursive function to return gcd of a and b  ` `static` `int` `__gcd(``int` `a, ``int` `b)  ` `{  ` ` ``return` `b == 0? a:__gcd(b, a % b);     ` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `[]arr = { 1, 2, 3, 4, 4, 3, 2, 1 };` `    ``int` `N = arr.Length;` `    ``Console.Write(CntOfSubsetsByPartitioning(arr, N));` `}` `}`   ` ``// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

`4`

Time Complexity: O(N * log(M)), where M is the smallest element of the array
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Recommended Articles
Page :