[Swift]LeetCode857. 雇佣 K 名工人的最低成本 | Minimum Cost to Hire K Workers

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

There are N workers.  The i-th worker has a quality[i] and a minimum wage expectation wage[i].

Now we want to hire exactly K workers to form a paid group.  When hiring a group of K workers, we must pay them according to the following rules:

1. Every worker in the paid group should be paid in the ratio of their quality compared to other workers in the paid group.
2. Every worker in the paid group must be paid at least their minimum wage expectation.

Return the least amount of money needed to form a paid group satisfying the above conditions. 

Example 1:

Input: quality = [10,20,5], wage = [70,50,30], K = 2
Output: 105.00000
Explanation: We pay 70 to 0-th worker and 35 to 2-th worker.

Example 2:

Input: quality = [3,1,10,10,1], wage = [4,8,2,2,7], K = 3
Output: 30.66667
Explanation: We pay 4 to 0-th worker, 13.33333 to 2-th and 3-th workers seperately.  

Note:

1. 1 <= K <= N <= 10000, where N = quality.length = wage.length
2. 1 <= quality[i] <= 10000
3. 1 <= wage[i] <= 10000
4. Answers within 10^-5 of the correct answer will be considered correct.

---

有 N 名工人。 第 i 名工人的工作质量为 quality[i] ，其最低期望工资为 wage[i] 。

现在我们想雇佣 K 名工人组成一个工资组。在雇佣 一组 K 名工人时，我们必须按照下述规则向他们支付工资：

1. 对工资组中的每名工人，应当按其工作质量与同组其他工人的工作质量的比例来支付工资。
2. 工资组中的每名工人至少应当得到他们的最低期望工资。

返回组成一个满足上述条件的工资组至少需要多少钱。 

示例 1：

输入： quality = [10,20,5], wage = [70,50,30], K = 2
输出： 105.00000
解释： 我们向 0 号工人支付 70，向 2 号工人支付 35。

示例 2：

输入： quality = [3,1,10,10,1], wage = [4,8,2,2,7], K = 3
输出： 30.66667
解释： 我们向 0 号工人支付 4，向 2 号和 3 号分别支付 13.33333。 

提示：

1. 1 <= K <= N <= 10000，其中 N = quality.length = wage.length
2. 1 <= quality[i] <= 10000
3. 1 <= wage[i] <= 10000
4. 与正确答案误差在 10^-5 之内的答案将被视为正确的。

---

260ms

class Solution {
    func mincostToHireWorkers(_ quality: [Int], _ wage: [Int], _ K: Int) -> Double {
  var workers: [(wage: Int, quality: Int)] = []
        
        for i in 0..<quality.count {
            workers.append((wage[i], quality[i]))
        }
        // Sort all workers with their expected ratio
        workers.sort { Double($0.wage) / Double($0.quality) < Double($1.wage) / Double($1.quality) } // O(n*logn)
        
        var heap = Heap(sort: >)
        
        var totalWage = Double(Int.max)
        var totalQuality = 0
        
        for worker in workers {
            let currRatio = Double(worker.wage)/Double(worker.quality)
            //print(currRatio)
            heap.push(worker.quality)
            totalQuality += worker.quality
            //print("total quality:", totalQuality)
            if heap.count > K {
                totalQuality -= heap.remove()!
            }
            if heap.count == K {
                totalWage = min(totalWage, Double(totalQuality) * currRatio)
                //print("current total wage:", totalWage)
            }
        }
        
        return totalWage
    }
}

// Implementation of heap
public struct Heap {
    
    var elements: [Int] = []
    let sort: (Int, Int) -> Bool
    var isEmpty: Bool {
        return self.elements.isEmpty
    }
    
    var count: Int {
        return self.elements.count
    }
    
    func peek() -> Int? {
        return elements.first
    }
    
    init(sort: @escaping (Int, Int) -> Bool, elements: [Int] = []) {
        self.sort = sort
        self.elements = elements
        
        if !elements.isEmpty {
            for i in stride(from: elements.count/2 - 1, through: 0, by: -1) {
                siftDown(from: i)
            }
        }
    }
    
    mutating func siftDown(from index: Int) {
        var parent = index
        while true {
            let left = leftIndex(of: parent)
            let right = rightIndex(of: parent)
            var candidate = parent
            if left < count && sort(elements[left], elements[candidate]) {
                candidate = left
            }
            if right < count && sort(elements[right], elements[candidate]) {
                candidate = right
            }
            if candidate == parent {
                return
            }
            elements.swapAt(parent, candidate)
            parent = candidate
        }
    }
    
    mutating func siftUp(from index: Int) {
        var child = index
        var parent = parentIndex(of: child)
        while child > 0 && sort(elements[child], elements[parent]) {
            elements.swapAt(child, parent)
            child = parent
            parent = parentIndex(of: child)
        }
    }
    
    mutating func push(_ element: Int) {
        elements.append(element)
        siftUp(from: count-1)
    }
    
    mutating func remove() -> Int? {
        guard !isEmpty else { return nil }
        elements.swapAt(0, count-1)
        defer {
            siftDown(from: 0)
        }
        return elements.popLast()
    }
    
    func leftIndex(of index: Int) -> Int {
        return (2 * index) + 1
    }
    
    func rightIndex(of index: Int) -> Int {
        return (2 * index) + 2
    }
    
    func parentIndex(of index: Int) -> Int {
        return (index - 1) / 2
    }
}

---

276ms

class Solution {
    func mincostToHireWorkers(_ quality: [Int], _ wage: [Int], _ K: Int) -> Double {
        var quaRatios = [(Int, Double)]()
        for i in 0..<quality.count {
            quaRatios.append((quality[i], Double(wage[i]) / Double(quality[i])))
        }
        quaRatios.sort { $0.1 < $1.1 }
        var pq = PriorityQueue<Int> { $0 > $1 }
        var sum = 0
        var result = Double(Int.max)
        for (qua, ratio) in quaRatios {
            sum += qua
            pq.enqueue(qua)
            if pq.count > K {
                sum -= pq.dequeue()!
            }
            if pq.count == K {
                result = min(result, ratio * Double(sum))
            }
        }
        return result
    }
}

public struct PriorityQueue<T> {
  fileprivate var heap: Heap<T>

  /*
    To create a max-priority queue, supply a > sort function. For a min-priority
    queue, use <.
  */
  public init(sort: @escaping (T, T) -> Bool) {
    heap = Heap(sort: sort)
  }

  public var isEmpty: Bool {
    return heap.isEmpty
  }

  public var count: Int {
    return heap.count
  }

  public func peek() -> T? {
    return heap.peek()
  }

  public mutating func enqueue(_ element: T) {
    heap.insert(element)
  }

  public mutating func dequeue() -> T? {
    return heap.remove()
  }

  /*
    Allows you to change the priority of an element. In a max-priority queue,
    the new priority should be larger than the old one; in a min-priority queue
    it should be smaller.
  */
  public mutating func changePriority(index i: Int, value: T) {
    return heap.replace(index: i, value: value)
  }
}

extension PriorityQueue where T: Equatable {
  public func index(of element: T) -> Int? {
    return heap.index(of: element)
  }
}

//
//  Heap.swift
//  Written for the Swift Algorithm Club by Kevin Randrup and Matthijs Hollemans
//
public struct Heap<T> {
  
  /** The array that stores the heap's nodes. */
  var nodes = [T]()
  
  /**
   * Determines how to compare two nodes in the heap.
   * Use '>' for a max-heap or '<' for a min-heap,
   * or provide a comparing method if the heap is made
   * of custom elements, for example tuples.
   */
  private var orderCriteria: (T, T) -> Bool
  
  /**
   * Creates an empty heap.
   * The sort function determines whether this is a min-heap or max-heap.
   * For comparable data types, > makes a max-heap, < makes a min-heap.
   */
  public init(sort: @escaping (T, T) -> Bool) {
    self.orderCriteria = sort
  }
  
  /**
   * Creates a heap from an array. The order of the array does not matter;
   * the elements are inserted into the heap in the order determined by the
   * sort function. For comparable data types, '>' makes a max-heap,
   * '<' makes a min-heap.
   */
  public init(array: [T], sort: @escaping (T, T) -> Bool) {
    self.orderCriteria = sort
    configureHeap(from: array)
  }
  
  /**
   * Configures the max-heap or min-heap from an array, in a bottom-up manner.
   * Performance: This runs pretty much in O(n).
   */
  private mutating func configureHeap(from array: [T]) {
    nodes = array
    for i in stride(from: (nodes.count/2-1), through: 0, by: -1) {
      shiftDown(i)
    }
  }
  
  public var isEmpty: Bool {
    return nodes.isEmpty
  }
  
  public var count: Int {
    return nodes.count
  }
  
  /**
   * Returns the index of the parent of the element at index i.
   * The element at index 0 is the root of the tree and has no parent.
   */
  @inline(__always) internal func parentIndex(ofIndex i: Int) -> Int {
    return (i - 1) / 2
  }
  
  /**
   * Returns the index of the left child of the element at index i.
   * Note that this index can be greater than the heap size, in which case
   * there is no left child.
   */
  @inline(__always) internal func leftChildIndex(ofIndex i: Int) -> Int {
    return 2*i + 1
  }
  
  /**
   * Returns the index of the right child of the element at index i.
   * Note that this index can be greater than the heap size, in which case
   * there is no right child.
   */
  @inline(__always) internal func rightChildIndex(ofIndex i: Int) -> Int {
    return 2*i + 2
  }
  
  /**
   * Returns the maximum value in the heap (for a max-heap) or the minimum
   * value (for a min-heap).
   */
  public func peek() -> T? {
    return nodes.first
  }
  
  /**
   * Adds a new value to the heap. This reorders the heap so that the max-heap
   * or min-heap property still holds. Performance: O(log n).
   */
  public mutating func insert(_ value: T) {
    nodes.append(value)
    shiftUp(nodes.count - 1)
  }
  
  /**
   * Adds a sequence of values to the heap. This reorders the heap so that
   * the max-heap or min-heap property still holds. Performance: O(log n).
   */
  public mutating func insert<S: Sequence>(_ sequence: S) where S.Iterator.Element == T {
    for value in sequence {
      insert(value)
    }
  }
  
  /**
   * Allows you to change an element. This reorders the heap so that
   * the max-heap or min-heap property still holds.
   */
  public mutating func replace(index i: Int, value: T) {
    guard i < nodes.count else { return }
    
    remove(at: i)
    insert(value)
  }
  
  /**
   * Removes the root node from the heap. For a max-heap, this is the maximum
   * value; for a min-heap it is the minimum value. Performance: O(log n).
   */
  @discardableResult public mutating func remove() -> T? {
    guard !nodes.isEmpty else { return nil }
    
    if nodes.count == 1 {
      return nodes.removeLast()
    } else {
      // Use the last node to replace the first one, then fix the heap by
      // shifting this new first node into its proper position.
      let value = nodes[0]
      nodes[0] = nodes.removeLast()
      shiftDown(0)
      return value
    }
  }
  
  /**
   * Removes an arbitrary node from the heap. Performance: O(log n).
   * Note that you need to know the node's index.
   */
  @discardableResult public mutating func remove(at index: Int) -> T? {
    guard index < nodes.count else { return nil }
    
    let size = nodes.count - 1
    if index != size {
      nodes.swapAt(index, size)
      shiftDown(from: index, until: size)
      shiftUp(index)
    }
    return nodes.removeLast()
  }
  
  /**
   * Takes a child node and looks at its parents; if a parent is not larger
   * (max-heap) or not smaller (min-heap) than the child, we exchange them.
   */
  internal mutating func shiftUp(_ index: Int) {
    var childIndex = index
    let child = nodes[childIndex]
    var parentIndex = self.parentIndex(ofIndex: childIndex)
    
    while childIndex > 0 && orderCriteria(child, nodes[parentIndex]) {
      nodes[childIndex] = nodes[parentIndex]
      childIndex = parentIndex
      parentIndex = self.parentIndex(ofIndex: childIndex)
    }
    
    nodes[childIndex] = child
  }
  
  /**
   * Looks at a parent node and makes sure it is still larger (max-heap) or
   * smaller (min-heap) than its childeren.
   */
  internal mutating func shiftDown(from index: Int, until endIndex: Int) {
    let leftChildIndex = self.leftChildIndex(ofIndex: index)
    let rightChildIndex = leftChildIndex + 1
    
    // Figure out which comes first if we order them by the sort function:
    // the parent, the left child, or the right child. If the parent comes
    // first, we're done. If not, that element is out-of-place and we make
    // it "float down" the tree until the heap property is restored.
    var first = index
    if leftChildIndex < endIndex && orderCriteria(nodes[leftChildIndex], nodes[first]) {
      first = leftChildIndex
    }
    if rightChildIndex < endIndex && orderCriteria(nodes[rightChildIndex], nodes[first]) {
      first = rightChildIndex
    }
    if first == index { return }
    
    nodes.swapAt(index, first)
    shiftDown(from: first, until: endIndex)
  }
  
  internal mutating func shiftDown(_ index: Int) {
    shiftDown(from: index, until: nodes.count)
  }
  
}

// MARK: - Searching
extension Heap where T: Equatable {
  
  /** Get the index of a node in the heap. Performance: O(n). */
  public func index(of node: T) -> Int? {
    return nodes.index(where: { $0 == node })
  }
  
  /** Removes the first occurrence of a node from the heap. Performance: O(n log n). */
  @discardableResult public mutating func remove(node: T) -> T? {
    if let index = index(of: node) {
      return remove(at: index)
    }
    return nil
  }  
}

---

Runtime: 304 ms

Memory Usage: 20 MB

class Solution {
    func mincostToHireWorkers(_ quality: [Int], _ wage: [Int], _ K: Int) -> Double {
        var workers:[[Double]] = [[Double]]()
        for i in 0..<quality.count
        {
            workers.append([Double(wage[i]) / Double(quality[i]), Double(quality[i])])
        }
        workers.sort(by:{(a:[Double],b:[Double]) -> Bool in
                        if a[0] == b[0]
                        {
                            return a[1] <= b[1]
                        }
                        else
                        {
                            return a[0] < b[0]
                        }})
        var res:Double = DBL_MAX
        var qsum:Double = 0
        var pq: PriorityQueue<Int> = PriorityQueue<Int>(false,[Int]())
        for worker in workers
        {
            let num:Double = worker[1]
            qsum += num
            pq.push(Int(num))
            if pq.count > K 
            {
                qsum -= Double(pq.pop()!)                
            }
            if pq.count == K
            {
                res = min(res, qsum * worker[0])
            }
        }
        return res
    }
}

public struct PriorityQueue<T: Comparable> {    
    fileprivate var heap = [T]()
    private let ordered: (T, T) -> Bool
    
    //创建具有给定顺序的新PriorityQueue。
    //order：true:降序 | false：升序
    //StartingValues:用于初始化PriorityQueue的元素数组。
    public init(_ ascending: Bool = false,_ startingValues: [T] = []) {
        self.init(order: ascending ? { $0 > $1 } : { $0 < $1 }, startingValues: startingValues)
    }
    
    public init(order: @escaping (T, T) -> Bool, startingValues: [T] = []) {
        ordered = order        
        //堆构造
        heap = startingValues
        var i = heap.count/2 - 1
        while i >= 0 {
            sink(i)
            i -= 1
        }
    }
    
    //优先级队列存储了多少个元素
    public var count: Int { return heap.count }
    
    //如果且仅当优先级队列为空时为true
    public var isEmpty: Bool { return heap.isEmpty }
    
    // 在优先级队列中添加新元素,复杂度：O(lg n)
    // element: 要插入优先级队列的元素.
    public mutating func push(_ element: T) {
        heap.append(element)
        swim(heap.count - 1)
    }
    
    //移除并返回具有最高优先级的元素（如果升序，则为最低优先级）。复杂度： O(lg n)
    //returns:优先级队列中优先级最高的元素，如果优先级队列为空，则为零。
    public mutating func pop() -> T? {        
        if heap.isEmpty { return nil }
        //增加了Swift 2兼容性
        if heap.count == 1 { return heap.removeFirst() } 
        //以便不使用同一位置的两个实例调用swap()
        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
        }
    }
    
    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
        }
    }
}

---

332ms

class Solution {
    func mincostToHireWorkers(_ quality: [Int], _ wage: [Int], _ K: Int) -> Double {
        var workers = [(Int, Double)]()
        for i in 0..<quality.count {
            workers.append((quality[i], Double(wage[i]) / Double(quality[i])))
        }
        workers = workers.sorted {
            $0.1 < $1.1
        }
        
        var heap = Heap<Int>(elements: [], priorityFunction: >)
        var total = 0, res = Double.infinity
        for (quality, ratio) in workers {
            if heap.count == K {
                if let top = heap.dequeue() {
                    total -= top
                }
            }
            
            heap.enqueue(quality)
            total += quality
            if heap.count == K {
                res = min(res, Double(total) * ratio)
            }
        }
        
        return res
    }
}

struct Heap<Element>
{
    var elements : [Element]
    let priorityFunction : (Element, Element) -> Bool

    init(elements: [Element] = [], priorityFunction: @escaping (Element, Element) -> Bool) {
        self.elements = elements
        self.priorityFunction = priorityFunction
        buildHeap()
    }

    mutating func buildHeap() {
        for index in (0 ..< count / 2).reversed() {
            siftDown(elementAtIndex: index)
        }
    }
    
    var isEmpty : Bool { return elements.isEmpty }
    var count : Int { return elements.count }

    func peek() -> Element? {
        return elements.first
    }

    mutating func enqueue(_ element: Element) {
        elements.append(element)
        siftUp(elementAtIndex: count - 1)
    }

    mutating func siftUp(elementAtIndex index: Int) {
        let parent = parentIndex(of: index)
        guard !isRoot(index),
            isHigherPriority(at: index, than: parent)
            else { return }
        swapElement(at: index, with: parent)
        siftUp(elementAtIndex: parent)
    }

    mutating func dequeue() -> Element? {
        guard !isEmpty
            else { return nil }
        swapElement(at: 0, with: count - 1)
        let element = elements.removeLast()
        if !isEmpty {
            siftDown(elementAtIndex: 0)
        }
        return element
    }
    
    mutating func siftDown(elementAtIndex index: Int) {
        let childIndex = highestPriorityIndex(for: index)
        if index == childIndex {
            return
        }
        swapElement(at: index, with: childIndex)
        siftDown(elementAtIndex: childIndex)
    }

    // Helper functions
    
    func isRoot(_ index: Int) -> Bool {
        return index == 0
    }
    
    func leftChildIndex(of index: Int) -> Int {
        return (2 * index) + 1
    }
    
    func rightChildIndex(of index: Int) -> Int {
        return (2 * index) + 2
    }
    
    func parentIndex(of index: Int) -> Int {
        return (index - 1) / 2
    }
    
    func isHigherPriority(at firstIndex: Int, than secondIndex: Int) -> Bool {
        return priorityFunction(elements[firstIndex], elements[secondIndex])
    }
    
    func highestPriorityIndex(of parentIndex: Int, and childIndex: Int) -> Int {
        guard childIndex < count && isHigherPriority(at: childIndex, than: parentIndex)
            else { return parentIndex }
        return childIndex
    }
    
    func highestPriorityIndex(for parent: Int) -> Int {
        return highestPriorityIndex(of: highestPriorityIndex(of: parent, and: leftChildIndex(of: parent)), and: rightChildIndex(of: parent))
    }
    
    mutating func swapElement(at firstIndex: Int, with secondIndex: Int) {
        guard firstIndex != secondIndex
            else { return }
        elements.swapAt(firstIndex, secondIndex)
    }
}

// A bonus extra for you: two extra functions, if the Element type is Equatable
extension Heap where Element : Equatable {
    
    // This function allows you to remove an element from the heap, in a similar way to how you would dequeue the root element.
    mutating func remove(_ element: Element) {
        guard let index = elements.index(of: element)
            else { return }
        swapElement(at: index, with: count - 1)
        elements.remove(at: count - 1)
        siftDown(elementAtIndex: index)
    }

    // This function allows you to 'boost' an element, by sifting the element up the heap. You might do this if the element is already in the heap, but its priority has increased since it was enqueued.
    mutating func boost(_ element: Element) {
        guard let index = elements.index(of: element)
            else { return }
        siftUp(elementAtIndex: index)
    }
}

---

376ms

class Solution {
    class Heap {
        var arr = [0]
        var count: Int {
            return arr.count-1
        }
        
        var top: Int {
            return arr[1]
        }
        
        func insert(_ num: Int) -> Void {
            arr.append(num)
            var i = arr.count-1
            while i > 1 {
                if arr[i] > arr[i/2] {
                    (arr[i], arr[i/2]) = (arr[i/2], arr[i])
                } else {
                    break
                }
                i /= 2
            }
        }
        
        func pop() -> Int {
            var ret = self.top
            var last = arr.removeLast()
            if self.count == 0 {
                return ret
            }
            
            arr[1] = last
            var i = 1
            while i < arr.count {
                let left = i*2
                let right = i*2+1
                var next = i
                if left < arr.count && arr[left] > arr[next] {
                    next = left
                }
                if right < arr.count && arr[right] > arr[next] {
                    next = right
                }
                if i != next {
                    (arr[i], arr[next]) = (arr[next], arr[i])
                    i = next
                } else {
                    break
                }
                
            }
            return ret
        }
    }
    func mincostToHireWorkers(_ quality: [Int], _ wage: [Int], _ K: Int) -> Double {

        var n = quality.count
        
        var ranks = [Int](repeating: 0, count: n)
        var ratios = [Double](repeating: 0.0, count: n)
        
        for i in 0..<n {
            ranks[i] = i
            ratios[i] = Double(wage[i])/Double(quality[i])
        }
        
        ranks.sort { (i1, i2) in
            if ratios[i1] == ratios[i2] {
                return quality[i1] < quality[i2]
            } else {
                return ratios[i1] < ratios[i2]
            }
        }
        
        var sum = 0.0;
        var heap = Heap()
        
        var ans = 1e9
        
        for rank in ranks {
            heap.insert(quality[rank])
            sum += Double(quality[rank])
            if heap.count > K {
                var maxQ = heap.pop()
                sum -= Double(maxQ)
            }
            if heap.count == K {
                // print(ans, sum, ratios[rank])
                ans = min(ans, sum*ratios[rank])
            }
        }
        return ans        
    }
}