[Swift]LeetCode1046.最后一块石头的重量 | Last Stone Weight

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

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

We have a collection of rocks, each rock has a positive integer weight.

Each turn, we choose the two heaviest rocks and smash them together.  Suppose the stones have weights x and y with x <= y.  The result of this smash is:

• If x == y, both stones are totally destroyed;
• If x != y, the stone of weight x is totally destroyed, and the stone of weight y has new weight y-x.

At the end, there is at most 1 stone left.  Return the weight of this stone (or 0 if there are no stones left.)

Note:

1. 1 <= stones.length <= 30
2. 1 <= stones[i] <= 1000

---

有一堆石头，每块石头的重量都是正整数。

每一回合，从中选出两块最重的石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

• 如果 x == y，那么两块石头都会被完全粉碎；
• 如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。

最后，最多只会剩下一块石头。返回此石头的重量。如果没有石头剩下，就返回 0。

提示：

1. 1 <= stones.length <= 30
2. 1 <= stones[i] <= 1000

---

8ms

class Solution {
    let heap = Heap<Int>(type: .max)
    
    func lastStoneWeight(_ stones: [Int]) -> Int {
        for stone in stones {
            heap.insert(stone)
        }
        
        return helper()
    }
    
    private func helper() -> Int {
        guard let a = heap.pop() else { return 0 }
        guard let b = heap.pop() else { return a }
        
        if a != b {
            heap.insert(a - b)
        }
        
        return helper()
    }
}

enum HeapType {
    case min
    case max
    
    func compare<T: Comparable>(_ a: T, _ b: T) -> Bool {
        switch self {
        case .min:
            return a < b
        case .max:
            return a > b
        }
    }
}

class Heap<T: Comparable> {
    // MARK: - Properties & Init
    var array: [T]
    var type: HeapType
    var nodeIndexUpdateHandler: ((Int) -> Void)? = nil
    
    init(type: HeapType, array: [T] = []) {
        self.type = type
        self.array = array
        
        guard !array.isEmpty else { return }
        
        var i = (array.count - 1) / 2
        while i >= 0 {
            heapify(i)
            i -= 1
        }
    }
    
    // MARK: - APIs
    
    var count: Int {
        return array.count
    }
    
    // O[1]
    func pop() -> T? {
        guard let first = array.first else {
            return nil
        }
        
        if let last = array.last {
            array[0] = last
            heapify(0)
        }
        
        array.removeLast()
        
        return first
    }
    
    // O[1]
    func peek() -> T? {
        return array.first
    }
    
    // O[log(n)]
    func insert(_ val: T) {
        array.append(val)
        nodeIndexUpdateHandler?(array.count - 1)
        siftUp(array.count - 1)
    }
    
    // MARK: - Utilty Methods
    func heapify(_ i: Int) {
        var top = i
        
        if let left = left(i), type.compare(array[left], array[top]) {
            top = left
        }
        
        if let right = right(i), type.compare(array[right], array[top]) {
            top = right
        }
        
        if top != i {
            swapAt(i, top)
            heapify(top)
        } else {
            nodeIndexUpdateHandler?(i)
        }
    }
    
    func siftUp(_ i: Int) {
        var parent = parentIndex(i)
        var this = i
        
        while let p = parent, type.compare(array[this], array[p]) {
            swapAt(p, this)
            parent = parentIndex(p)
            this = p
        }
    }
    
    func swapAt(_ i: Int, _ j: Int) {
        array.swapAt(i, j)
        nodeIndexUpdateHandler?(i)
        nodeIndexUpdateHandler?(j)
    }
    
    func parentIndex(_ i: Int) -> Int? {
        guard i > 0 else { return nil }
        return (i - 1) / 2
    }
    
    func left(_ i: Int) -> Int? {
        let left = i * 2 + 1
        return left < array.count ? left : nil
    }
    
    func right(_ i: Int) -> Int? {
        let right = i * 2 + 2
        return right < array.count ? right : nil
    }
}

---

Runtime: 12 ms

Memory Usage: 21.1 MB

class Solution {
    func lastStoneWeight(_ stones: [Int]) -> Int {
        var stones = stones
        while (stones.count > 1)
        {
            stones = stones.sorted()
            stones.append(abs(stones.popLast()! - stones.popLast()!))
        }
        return stones[0]        
    }
}