Sunday, July 21, 2024

[LeetCode] Maximum Frequency Stack

Problem: Design a stack-like data structure to push elements to the stack and pop the most frequent element from the stack.

Implement the FreqStack class:

  • FreqStack() constructs an empty frequency stack.
  • void push(int val) pushes an integer val onto the top of the stack.
  • int pop() removes and returns the most frequent element in the stack.
    • If there is a tie for the most frequent element, the element closest to the stack's top is removed and returned.

Example:

Input
["FreqStack", "push", "push", "push", "push", "push", "push", "pop", "pop", "pop", "pop"]
[[], [5], [7], [5], [7], [4], [5], [], [], [], []]
Output
[null, null, null, null, null, null, null, 5, 7, 5, 4]

Explanation
FreqStack freqStack = new FreqStack();
freqStack.push(5); // The stack is [5]
freqStack.push(7); // The stack is [5,7]
freqStack.push(5); // The stack is [5,7,5]
freqStack.push(7); // The stack is [5,7,5,7]
freqStack.push(4); // The stack is [5,7,5,7,4]
freqStack.push(5); // The stack is [5,7,5,7,4,5]
freqStack.pop();   // return 5, as 5 is the most frequent. The stack becomes [5,7,5,7,4].
freqStack.pop();   // return 7, as 5 and 7 is the most frequent, but 7 is closest to the top. The stack becomes [5,7,5,4].
freqStack.pop();   // return 5, as 5 is the most frequent. The stack becomes [5,7,4].
freqStack.pop();   // return 4, as 4, 5 and 7 is the most frequent, but 4 is closest to the top. The stack becomes [5,7].

Constraints:

  • 0 <= val <= 109
  • At most 2 * 104 calls will be made to push and pop.
  • It is guaranteed that there will be at least one element in the stack before calling pop.


Approach: We can use two hash maps to solve this problem:

  1. FrequencyMap: This map will have frequency as key and corresponding list of elements as values.
  2. ElementsMap: This map will have elements as key and it's frequency as value.

Once we have two maps in our class along with a member integer say max_frequncy, We can apply following operations at push and pop:

Push: 

    ElementsMap[val] = ElementsMap[val] + 1

    curr_freq = ElementsMap[val]

    FrequencyMap[curr_freq].AddAtLast(val)

    max_freq = MAX(curr_freq, max_freq)

Pop:

    val = FrequencyMap[max_freq].GetLast()

    FrequencyMap[max_freq].RemoveLast()

    IF ISEMPTY(FrequencyMap[max_freq])):

        FrequencyMap.Remove(max_freq)

        --max_freq

    ElementsMap[val] = ElementsMap[val] - 1

    RETURN val

That's all!


Implemetation in C#:

public class FreqStack
{
    public FreqStack()
    {
        this.freqMap = new Dictionary<int, List<int>>();
        this.elementsMap = new Dictionary<int, int>();
        this.maxFreq = 0;
    }
   
    public void Push(int val)
    {
        if (!elementsMap.ContainsKey(val))
        {
            elementsMap[val] = 0;
        }
        ++elementsMap[val];
        int currFreq = elementsMap[val];
        if (!freqMap.ContainsKey(currFreq))
        {
            freqMap[currFreq] = new List<int>();
        }
        freqMap[currFreq].Add(val);
        if (currFreq > this.maxFreq)
        {
            this.maxFreq = currFreq;
        }
    }
   
    public int Pop()
    {
        int maxFreqListCount = this.freqMap[this.maxFreq].Count;
        int val = this.freqMap[this.maxFreq][maxFreqListCount - 1];
        this.freqMap[this.maxFreq].RemoveAt(maxFreqListCount - 1);
        if (this.freqMap[this.maxFreq].Count == 0)
        {
            this.freqMap.Remove(this.maxFreq);
            --this.maxFreq;
        }
        --this.elementsMap[val];
        if (this.elementsMap[val] == 0)
        {
            this.elementsMap.Remove(val);
        }
        return val;
    }

    private Dictionary<int, List<int>> freqMap;
    private Dictionary<int, int> elementsMap;
    int maxFreq;
}

Complexiy: O(1) for push and pop.

No comments:

Post a Comment