Smallest subarray with all occurrences of a most frequent element

Given an array, A.Let x be an element in the array.x has the maximum frequency in the array.Find the smallest subsegment of the array which also has x as the maximum frequency element.

Examples:

```Input :  arr[] = {4, 1, 1, 2, 2, 1, 3, 3}
Output :   1, 1, 2, 2, 1
The most frequent element is 1. The smallest
subarray that has all occurrences of it is
1 1 2 2 1

Input :  A[] = {1, 2, 2, 3, 1}
Output : 2, 2
Note that there are two elements that appear
two times, 1 and 2. The smallest window for
1 is whole array and smallest window for 2 is
{2, 2}. Since window for 2 is smaller, this is
our output.
```

Recommended: Please solve it on PRACTICE first, before moving on to the solution.

Approach:Observe that if X is the maximum repeated element of our subsegment then the sunsegment should look like this [X, ….., X], cause if the subsegment end or begins with another element we can delete it which does not alter our answer.
To solve this problem, let us store for every distinct element in the array three values, index of the first occurrence of the element and the index of the last occurrence the element and the frequency of the element. And at every step for a maximum repeated element minimize the size of our subsegment.

C++

 `// C++ implementation to find smallest ` `// subarray with all occurrences of  ` `// a most frequent element ` `#include ` `using` `namespace` `std; ` ` `  `void` `smallestSubsegment(``int` `a[], ``int` `n) ` `{ ` `    ``// To store left most occurrence of elements ` `    ``unordered_map<``int``, ``int``> left; ` ` `  `    ``// To store counts of elements ` `    ``unordered_map<``int``, ``int``> count; ` ` `  `    ``// To store maximum frequency ` `    ``int` `mx = 0; ` ` `  `    ``// To store length and starting index of ` `    ``// smallest result window ` `    ``int` `mn, strindex; ` ` `  `    ``for` `(``int` `i = 0; i < n; i++) { ` ` `  `        ``int` `x = a[i]; ` ` `  `        ``// First occurrence of an element, ` `        ``// store the index ` `        ``if` `(count[x] == 0) { ` `            ``left[x] = i; ` `            ``count[x] = 1; ` `        ``} ` ` `  `        ``// increase the frequency of elements ` `        ``else` `            ``count[x]++; ` ` `  `        ``// Find maximum repeated element and  ` `        ``// store its last occurrence and first  ` `        ``// occurrence ` `        ``if` `(count[x] > mx) { ` `            ``mx = count[x]; ` `            ``mn = i - left[x] + 1; ``// length of subsegment ` `            ``strindex = left[x]; ` `        ``} ` ` `  `        ``// select subsegment of smallest size ` `        ``else` `if` `(count[x] == mx && i - left[x] + 1 < mn) { ` `            ``mn = i - left[x] + 1; ` `            ``strindex = left[x]; ` `        ``} ` `    ``} ` ` `  `    ``// Print the subsegment with all occurrences of ` `    ``// a most frequent element ` `    ``for` `(``int` `i = strindex; i < strindex + mn; i++) ` `        ``cout << a[i] << ``" "``; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `A[] = { 1, 2, 2, 2, 1 }; ` `    ``int` `n = ``sizeof``(A) / ``sizeof``(A[0]); ` `    ``smallestSubsegment(A, n); ` `    ``return` `0; ` `} `

Java

 `// Java implementation to find smallest ` `// subarray with all occurrences of  ` `// a most frequent element ` `import` `java.io.*; ` `import` `java.util.*; ` `class` `GfG { ` `     `  `    ``static` `void` `smallestSubsegment(``int` `a[], ``int` `n) ` `    ``{ ` `        ``// To store left most occurrence of elements ` `        ``HashMap left= ``new` `HashMap(); ` `     `  `        ``// To store counts of elements ` `        ``HashMap count= ``new` `HashMap(); ` `     `  `        ``// To store maximum frequency ` `        ``int` `mx = ``0``; ` `     `  `        ``// To store length and starting index of ` `        ``// smallest result window ` `        ``int` `mn = -``1``, strindex = -``1``; ` `     `  `        ``for` `(``int` `i = ``0``; i < n; i++) ` `        ``{ ` `     `  `            ``int` `x = a[i]; ` `     `  `            ``// First occurrence of an element, ` `            ``// store the index ` `            ``if` `(count.get(x) == ``null``) ` `            ``{ ` `                ``left.put(x, i) ; ` `                ``count.put(x, ``1``); ` `            ``} ` `     `  `            ``// increase the frequency of elements ` `            ``else` `                ``count.put(x, count.get(x) + ``1``); ` `     `  `            ``// Find maximum repeated element and  ` `            ``// store its last occurrence and first  ` `            ``// occurrence ` `            ``if` `(count.get(x) > mx)  ` `            ``{ ` `                ``mx = count.get(x); ` `                 `  `                ``// length of subsegment ` `                ``mn = i - left.get(x) + ``1``;  ` `                ``strindex = left.get(x); ` `            ``} ` `     `  `            ``// select subsegment of smallest size ` `            ``else` `if` `((count.get(x) == mx) && ` `                    ``(i - left.get(x) + ``1` `< mn))  ` `            ``{ ` `                ``mn = i - left.get(x) + ``1``; ` `                ``strindex = left.get(x); ` `            ``} ` `        ``} ` `     `  `        ``// Print the subsegment with all occurrences of ` `        ``// a most frequent element ` `        ``for` `(``int` `i = strindex; i < strindex + mn; i++) ` `            ``System.out.print(a[i] + ``" "``); ` `    ``} ` `     `  `    ``// Driver program ` `    ``public` `static` `void` `main (String[] args)  ` `    ``{ ` `        ``int` `A[] = { ``1``, ``2``, ``2``, ``2``, ``1` `}; ` `        ``int` `n = A.length; ` `        ``smallestSubsegment(A, n); ` `    ``} ` `} ` ` `  `// This code is contributed by Gitanjali. `

Python3

 `# Python3 implementation to find smallest ` `# subarray with all occurrences of ` `# a most frequent element ` `def` `smallestSubsegment(a, n): ` `     `  `    ``# To store left most occurrence of elements ` `    ``left ``=` `dict``() ` ` `  `    ``# To store counts of elements ` `    ``count ``=` `dict``() ` ` `  `    ``# To store maximum frequency ` `    ``mx ``=` `0` ` `  `    ``# To store length and starting index of ` `    ``# smallest result window ` `    ``mn, strindex ``=` `0``, ``0` ` `  `    ``for` `i ``in` `range``(n): ` ` `  `        ``x ``=` `a[i] ` ` `  `        ``# First occurrence of an element, ` `        ``# store the index ` `        ``if` `(x ``not` `in` `count.keys()): ` `            ``left[x] ``=` `i ` `            ``count[x] ``=` `1` ` `  `        ``# increase the frequency of elements ` `        ``else``: ` `            ``count[x] ``+``=` `1` ` `  `        ``# Find maximum repeated element and ` `        ``# store its last occurrence and first ` `        ``# occurrence ` `        ``if` `(count[x] > mx): ` `            ``mx ``=` `count[x] ` `            ``mn ``=` `i ``-` `left[x] ``+` `1` `# length of subsegment ` `            ``strindex ``=` `left[x] ` ` `  `        ``# select subsegment of smallest size ` `        ``elif` `(count[x] ``=``=` `mx ``and`  `              ``i ``-` `left[x] ``+` `1` `< mn): ` `            ``mn ``=` `i ``-` `left[x] ``+` `1` `            ``strindex ``=` `left[x] ` `             `  `    ``# Print the subsegment with all occurrences of ` `    ``# a most frequent element ` `    ``for` `i ``in` `range``(strindex, strindex ``+` `mn): ` `        ``print``(a[i], end ``=` `" "``) ` ` `  `# Driver code ` `A ``=` `[``1``, ``2``, ``2``, ``2``, ``1``] ` `n ``=` `len``(A) ` `smallestSubsegment(A, n) ` ` `  `# This code is contributed by Mohit Kumar `

C#

 `// C# implementation to find smallest ` `// subarray with all occurrences of  ` `// a most frequent element ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GfG  ` `{ ` `     `  `    ``static` `void` `smallestSubsegment(``int` `[]a, ``int` `n) ` `    ``{ ` `        ``// To store left most occurrence of elements ` `        ``Dictionary<``int``, ``int``> left = ``new` `Dictionary<``int``, ``int``>(); ` `     `  `        ``// To store counts of elements ` `        ``Dictionary<``int``, ``int``> count = ``new` `Dictionary<``int``, ``int``>(); ` `     `  `        ``// To store maximum frequency ` `        ``int` `mx = 0; ` `     `  `        ``// To store length and starting index of ` `        ``// smallest result window ` `        ``int` `mn = -1, strindex = -1; ` `     `  `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``{ ` `     `  `            ``int` `x = a[i]; ` `     `  `            ``// First occurrence of an element, ` `            ``// store the index ` `            ``if` `(!count.ContainsKey(x)) ` `            ``{ ` `                ``left.Add(x, i) ; ` `                ``count.Add(x, 1); ` `            ``} ` `     `  `            ``// increase the frequency of elements ` `            ``else` `                ``count[x] = count[x] + 1; ` `     `  `            ``// Find maximum repeated element and  ` `            ``// store its last occurrence and first  ` `            ``// occurrence ` `            ``if` `(count[x] > mx)  ` `            ``{ ` `                ``mx = count[x]; ` `                 `  `                ``// length of subsegment ` `                ``mn = i - left[x] + 1;  ` `                ``strindex = left[x]; ` `            ``} ` `     `  `            ``// select subsegment of smallest size ` `            ``else` `if` `((count[x] == mx) && ` `                    ``(i - left[x] + 1 < mn))  ` `            ``{ ` `                ``mn = i - left[x] + 1; ` `                ``strindex = left[x]; ` `            ``} ` `        ``} ` `     `  `        ``// Print the subsegment with all occurrences of ` `        ``// a most frequent element ` `        ``for` `(``int` `i = strindex; i < strindex + mn; i++) ` `            ``Console.Write(a[i] + ``" "``); ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `Main (String[] args)  ` `    ``{ ` `        ``int` `[]A = { 1, 2, 2, 2, 1 }; ` `        ``int` `n = A.Length; ` `        ``smallestSubsegment(A, n); ` `    ``} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

Output:

```2 2 2
```

Time Complexity: O(n)

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.