leetcode 895. Maximum Frequency Stack

（自开发的博客网址，欢迎访问） https://www.weiboke.online/

895. Maximum Frequency Stack

Implement FreqStack, a class which simulates the operation of a stack-like data structure.

FreqStack has two functions:

push(int x), which pushes an integer x onto the stack.
pop(), which removes and returns the most frequent element in the stack.
If there is a tie for most frequent element, the element closest to the top of the stack is removed and returned.

Example 1:

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:
After making six .push operations, the stack is [5,7,5,7,4,5] from bottom to top. Then:

pop() -> returns 5, as 5 is the most frequent.
The stack becomes [5,7,5,7,4].

pop() -> returns 7, as 5 and 7 is the most frequent, but 7 is closest to the top.
The stack becomes [5,7,5,4].

pop() -> returns 5.
The stack becomes [5,7,4].

pop() -> returns 4.
The stack becomes [5,7].

Note:

Calls to FreqStack.push(int x) will be such that 0 <= x <= 10^9.
It is guaranteed that FreqStack.pop() won’t be called if the stack has zero elements.
The total number of FreqStack.push calls will not exceed 10000 in a single test case.
The total number of FreqStack.pop calls will not exceed 10000 in a single test case.
The total number of FreqStack.push and FreqStack.pop calls will not exceed 150000 across all test cases.

Approach

方法一： 使用堆，堆顶是出现次数最多，离栈顶最近的数据，使用hashmap辅助计数，还有一个自增数，用来标识每个数的顺序序。
方法二：使用两个Hashmap，一个用来计数，另一个用栈装某频率次数中顺序情况。

Code

One

struct node {
    int value, cnt, index;

    bool operator<(node x) const {
        if (this->cnt == x.cnt)return this->index < x.index;
        else return this->cnt < x.cnt;
    }

    node(int _v, int _c, int _i) : value(_v), cnt(_c), index(_i) {}
};

class FreqStack {
private:
    int index;
    unordered_map<int, int> unmp;
    priority_queue<node> heap;
public:
    FreqStack() {
        index = 0;
    }

    void push(int x) {
        unmp[x]++;
        index++;
        heap.push(node(x, unmp[x], index));
    }

    int pop() {
        node a = heap.top();
        heap.pop();
        unmp[a.value]--;
        return a.value;
    }
};

TWO

class FreqStack {
private:
    unordered_map<int, int> freq;
    unordered_map<int, stack<int>> unmp;
    int maxFreq = 0;
public:
    FreqStack() {

    }

    void push(int x) {
        maxFreq = max(maxFreq, ++freq[x]);
        unmp[freq[x]].push(x);
    }

    int pop() {
        int top = unmp[maxFreq].top();
        unmp[maxFreq].pop();
        if (unmp[freq[top]--].empty())maxFreq--;
        return top;
    }
};