Count Elements With Maximum Frequency

Problem Statement

In the given problem, you are provided with an array nums composed entirely of positive integers. The task is to determine the total occurrences of the elements in the array that share the highest frequency of appearance. Specifically, the frequency of an element is defined as the number of times it appears in that array. The objective is to sum up the frequencies of all such elements that have the most repetitions in the array, and return this sum.

Examples

Example 1

Input:

nums = [1,2,2,3,1,4]

Output:

4

Explanation:

The elements 1 and 2 have a frequency of 2 which is the maximum frequency in the array.
So the number of elements in the array with maximum frequency is 4.

Example 2

Input:

nums = [1,2,3,4,5]

Output:

5

Explanation:

All elements of the array have a frequency of 1 which is the maximum.
So the number of elements in the array with maximum frequency is 5.

Constraints

• 1 <= nums.length <= 100
• 1 <= nums[i] <= 100

Approach and Intuition

The solution to this problem involves a few clear computational steps:

1. Count the occurrences of each number in the given array. This can be efficiently done using a dictionary where the keys are the elements of the array and the values are their corresponding counts.

2. Determine the maximum frequency from these counts. This involves comparing the frequency values and capturing the highest one.

3. Aggregate the frequencies of all numbers that share this maximum frequency by simply iterating over our counts and summing the ones that match the maximum frequency.

Here's the conceptual breakdown using the provided examples:

• For Example 1:

  • nums = [1,2,2,3,1,4]
  • Frequencies would look like {1:2, 2:2, 3:1, 4:1}
  • The maximum frequency is 2.
  • Sum the counts of all elements that have the frequency 2 which gives us 2 + 2 = 4.

• For Example 2:

  • nums = [1,2,3,4,5]
  • Each element appears exactly once, so the frequencies are {1:1, 2:1, 3:1, 4:1, 5:1}
  • The maximum frequency again, in this case, is 1.
  • Summate the frequencies, resulting in 1 + 1 + 1 + 1 + 1 = 5.

By leveraging the properties of dictionary data structures for counting and simple iterations for evaluating conditions, the problem can be efficiently solved even as the size of the array reaches its upper constraint.

Solutions

class Solution {
public:
    int retrieveMaxFrequencyTotal(vector<int>& elements) {
        unordered_map<int, int> elemFreq;
        int highestFreq = 0;
        int frequencySum = 0;
    
        for (int element : elements) {
            elemFreq[element]++;
            int currentFreq = elemFreq[element];
    
            if (currentFreq > highestFreq) {
                highestFreq = currentFreq;
                frequencySum = currentFreq;
            } else if (currentFreq == highestFreq) {
                frequencySum += currentFreq;
            }
        }
        return frequencySum;
    }
};