[Swift]LeetCode895. 最大频率栈 | Maximum Frequency Stack

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址： https://www.cnblogs.com/strengthen/p/10605780.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

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.

---

实现 FreqStack，模拟类似栈的数据结构的操作的一个类。

FreqStack 有两个函数：

• push(int x)，将整数 x 推入栈中。
• pop()，它移除并返回栈中出现最频繁的元素。
  • 如果最频繁的元素不只一个，则移除并返回最接近栈顶的元素。 

示例：

输入：
["FreqStack","push","push","push","push","push","push","pop","pop","pop","pop"],
[[],[5],[7],[5],[7],[4],[5],[],[],[],[]]
输出：[null,null,null,null,null,null,null,5,7,5,4]
解释：
执行六次 .push 操作后，栈自底向上为 [5,7,5,7,4,5]。然后：

pop() -> 返回 5，因为 5 是出现频率最高的。
栈变成 [5,7,5,7,4]。

pop() -> 返回 7，因为 5 和 7 都是频率最高的，但 7 最接近栈顶。
栈变成 [5,7,5,4]。

pop() -> 返回 5 。
栈变成 [5,7,4]。

pop() -> 返回 4 。
栈变成 [5,7]。 

提示：

• 对 FreqStack.push(int x) 的调用中 0 <= x <= 10^9。
• 如果栈的元素数目为零，则保证不会调用  FreqStack.pop()。
• 单个测试样例中，对 FreqStack.push 的总调用次数不会超过 10000。
• 单个测试样例中，对 FreqStack.pop 的总调用次数不会超过 10000。
• 所有测试样例中，对 FreqStack.push 和 FreqStack.pop 的总调用次数不会超过 150000。 

---

Runtime: 920 ms

Memory Usage: 22.3 MB

class FreqStack {
    var freq:[Int:Int]
    var m:[Int:[Int]]
    var maxfreq:Int
    init() {
        freq = [Int:Int]()
        m = [Int:[Int]]()
        maxfreq = 0        
    }
    
    func push(_ x: Int) {
        var f:Int = freq[x,default:0] + 1
        freq[x] = f
        maxfreq = max(maxfreq, f)
        m[f,default:[Int]()].append(x)      
    }
    
    func pop() -> Int {
        var x:Int = m[maxfreq,default:[Int]()].popLast() ?? 0
        freq[x] = maxfreq - 1
        if m[maxfreq,default:[Int]()].count == 0 {maxfreq -= 1}
        return x     
    }
}

/**
 * Your FreqStack object will be instantiated and called as such:
 * let obj = FreqStack()
 * obj.push(x)
 * let ret_2: Int = obj.pop()
 */
 

---

1016ms

class FreqStack {
    
    var appearancesByValues = [Int: Int]()
    var valuesByAppearances = [Int: [Int]]()

    var maxAppearances = 1
    let emptySet = Set<Int>()

    init() {

    }

    func push(_ x: Int) {

        let appearances = self.appearancesByValues[x, default: 0] + 1
        self.appearancesByValues[x] = appearances

        if appearances > self.maxAppearances {
            self.maxAppearances = appearances
        }
        self.valuesByAppearances[appearances, default: []].append(x)

    }

    func pop() -> Int {

        let value = (self.valuesByAppearances[self.maxAppearances]?.popLast())!

        self.appearancesByValues[value]! -= 1

        if self.valuesByAppearances[self.maxAppearances]?.count == 0 {
            self.maxAppearances -= 1
        }

        return value
    }
}

---

1024ms

class FreqStack {
    
    var freq: [Int: Int] // num: freq
    var group: [Int: [Int]] // freq: stack of elements w/ same freq
    var maxFreq: Int

    init() {
        self.freq = [Int: Int]()
        self.group = [Int: [Int]]()
        self.maxFreq = 0
    }
    
    func push(_ x: Int) {
        let f = (freq[x] ?? 0) + 1
        freq[x] = f
        if var stack = group[f] {
            stack.append(x)
            group[f] = stack
        } else {
            group[f] = [x]
        }
        if f > maxFreq {
            maxFreq = f
        }
    }
    
    func pop() -> Int {
        var stack = group[maxFreq]!
        let result = stack.removeLast()
        freq[result] = maxFreq - 1
        group[maxFreq] = stack
        if stack.count == 0 {
            maxFreq -= 1
        }
        return result
    }
}

---

1068ms

class FreqStack {

    init() {
        
    }
    
    func push(_ x: Int) {
        let f = elem2Freq[x, default: 0] + 1
        elem2Freq[x] = f
        let sz = subStacks.count
        if f >= sz {
            subStacks.append([x])
        } else {
            subStacks[f].append(x)
        }
    }
    
    func pop() -> Int {
        let sz = subStacks.count
        let x = subStacks[sz - 1].popLast()!
        if subStacks[sz - 1].isEmpty {
            subStacks.removeLast()
        }
        elem2Freq[x, default: 0] -= 1
        return x
    }
    
    var elem2Freq = [Int: Int]()
    var subStacks = [[Int]()]
}

---

1432ms

public struct PriorityQueue<T: Comparable> {    
    fileprivate var heap = [T]()
    private let ordered: (T, T) -> Bool
    
    public init(ascending: Bool = false, startingValues: [T] = []) {
        self.init(order: ascending ? { $0 > $1 } : { $0 < $1 }, startingValues: startingValues)
    }
    
    // Creates a new PriorityQueue with the given ordering.
    // - parameter order: A function that specifies whether its first argument should
    //   come after the second argument in the PriorityQueue.
    // - parameter startingValues: An array of elements to initialize the PriorityQueue with.
    public init(order: @escaping (T, T) -> Bool, startingValues: [T] = []) {
        ordered = order
        
        //Based on "Heap construction" from Sedgewick p 323
        heap = startingValues
        var i = heap.count/2 - 1
        while i >= 0 {
            sink(i)
            i -= 1
        }
    }
    
    // How many elements the Priority Queue stores
    public var count: Int { return heap.count }
    
    // true if and only if the Priority Queue is empty
    public var isEmpty: Bool { return heap.isEmpty }
    
    // Add a new element onto the Priority Queue. O(lg n)
    // - parameter element: The element to be inserted into the Priority Queue.
    public mutating func push(_ element: T) {
        heap.append(element)
        swim(heap.count - 1)
    }
    
    // Remove and return the element with the highest priority (or lowest if ascending). O(lg n)
    // - returns: The element with the highest priority in the Priority Queue, or nil if the PriorityQueue is empty.
    public mutating func pop() -> T? {
        
        if heap.isEmpty { return nil }
        // added for Swift 2 compatibility
        if heap.count == 1 { return heap.removeFirst() } 
        // so as not to call swap() with two instances of the same location
        heap.swapAt(0, heap.count - 1)
        let temp = heap.removeLast()
        sink(0)
        
        return temp
    }
    
    private mutating func sink(_ index: Int) {
        var index = index
        while 2 * index + 1 < heap.count {            
            var j = 2 * index + 1            
            if j < (heap.count - 1) && ordered(heap[j], heap[j + 1]) { j += 1 }
            if !ordered(heap[index], heap[j]) { break }            
            heap.swapAt(index, j)
            index = j
        }
    }
    
    // Based on example from Sedgewick p 316
    private mutating func swim(_ index: Int) {
        var index = index
        while index > 0 && ordered(heap[(index - 1) / 2], heap[index]) {
            heap.swapAt((index - 1) / 2, index)
            index = (index - 1) / 2
        }
    }
}

struct Entry: Comparable {
    let x: Int
    let priority: Int
    
    static func == (lhs: Entry, rhs: Entry) -> Bool {
        return lhs.priority == rhs.priority
    }
    
    static func < (lhs: Entry, rhs: Entry) -> Bool {
        return lhs.priority < rhs.priority
    }
    
    static func <= (lhs: Entry, rhs: Entry) -> Bool {
        return lhs.priority <= rhs.priority
    }

    static func > (lhs: Entry, rhs: Entry) -> Bool {
        return lhs.priority > rhs.priority
    }
    
    static func >= (lhs: Entry, rhs: Entry) -> Bool {
        return lhs.priority >= rhs.priority
    }
}

class FreqStack {
    
    var pq: PriorityQueue<Entry>
    var freq: [Int: Int] = [:]
    
    init() {
        pq = PriorityQueue<Entry>(ascending: false, startingValues: [])
    }
    
    let maxN = 10000
    var pushCount = 0
    func push(_ x: Int) {
        let count = freq[x, default: 0] + 1
        freq[x] = count
        pushCount += 1
        pq.push(Entry(x: x, priority:  count * maxN + pushCount))
    }
    
    func pop() -> Int {
        let entry = pq.pop()!
        freq[entry.x] = freq[entry.x]! - 1
        return entry.x
    }
}

/**
 * Your FreqStack object will be instantiated and called as such:
 * let obj = FreqStack()
 * obj.push(x)
 * let ret_2: Int = obj.pop()
 */