[Swift]LeetCode826. 安排工作以达到最大收益 | Most Profit Assigning Work

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

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

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

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

We have jobs: difficulty[i] is the difficulty of the ith job, and profit[i] is the profit of the ith job. 

Now we have some workers. worker[i] is the ability of the ith worker, which means that this worker can only complete a job with difficulty at most worker[i]. 

Every worker can be assigned at most one job, but one job can be completed multiple times.

For example, if 3 people attempt the same job that pays $1, then the total profit will be $3.  If a worker cannot complete any job, his profit is $0.

What is the most profit we can make?

Example 1:

Input: difficulty = [2,4,6,8,10], profit = [10,20,30,40,50], worker = [4,5,6,7]
Output: 100 
Explanation: Workers are assigned jobs of difficulty [4,4,6,6] and they get profit of [20,20,30,30] seperately.

Notes:

• 1 <= difficulty.length = profit.length <= 10000
• 1 <= worker.length <= 10000
• difficulty[i], profit[i], worker[i]  are in range [1, 10^5]

---

有一些工作：difficulty[i] 表示第i个工作的难度，profit[i]表示第i个工作的收益。

现在我们有一些工人。worker[i]是第i个工人的能力，即该工人只能完成难度小于等于worker[i]的工作。

每一个工人都最多只能安排一个工作，但是一个工作可以完成多次。

举个例子，如果3个工人都尝试完成一份报酬为1的同样工作，那么总收益为 $3。如果一个工人不能完成任何工作，他的收益为 $0 。

我们能得到的最大收益是多少？

示例：

输入: difficulty = [2,4,6,8,10], profit = [10,20,30,40,50], worker = [4,5,6,7]
输出: 100 
解释: 工人被分配的工作难度是 [4,4,6,6] ，分别获得 [20,20,30,30] 的收益。

提示:

• 1 <= difficulty.length = profit.length <= 10000
• 1 <= worker.length <= 10000
• difficulty[i], profit[i], worker[i]  的范围是 [1, 10^5]

---

580ms

class Solution {
    func maxProfitAssignment(_ difficulty: [Int], _ profit: [Int], _ worker: [Int]) -> Int {
        var tasks = [(Int, Int)]()
        for i in 0..<difficulty.count {
            tasks.append((profit[i], difficulty[i]))
        }
        tasks = tasks.sorted {$0.0 > $1.0}
        var workers = worker.sorted {$0 > $1}
        var t = 0, w = 0
        var res = 0
        while (w < worker.count && t < tasks.count) {
            if tasks[t].1 <= workers[w] {
                res += tasks[t].0
                w += 1
            } else {
                t += 1
            }
        }
        return res
    }
}

---

588ms

class Solution {    
    func maxProfitAssignment(_ difficulty: [Int], _ profit: [Int], _ worker: [Int]) -> Int {
        let dp = zip(difficulty, profit).sorted(by: {$0.0 < $1.0})
        
        var p = 0
        var i = 0, maxp = 0
        for w in worker.sorted(by: <) {
            while i < dp.count && w >= dp[i].0 {
                maxp = max(maxp, dp[i].1)
                i += 1
            }
            p += maxp
        }        
        return p
    }
}

---

616ms

class Solution {
    func maxProfitAssignment(_ difficulty: [Int], _ profit: [Int], _ worker: [Int]) -> Int {
        var dp = [Int : Int]()
        for i in 0..<difficulty.count {
            let d = difficulty[i]
            let p = profit[i]
            if dp[d, default: 0] < p {
                dp[d] = p
            }
        }
        let keys = dp.keys.sorted()
        var maxSoFar = 0
        var sanitizedD = [Int]()
        var sanitizedP = [Int]()
        for i in 0..<keys.count {
            let key = keys[i]
            if dp[key]! > maxSoFar {
                maxSoFar = dp[key]!
                sanitizedD.append(key)
                sanitizedP.append(dp[key]!)
            }
        }

        var result = 0
        for i in 0..<worker.count {
            let w = worker[i]
            result += maxFittingProfit(forWorker: w, inDifficulties: sanitizedD, withProfits:sanitizedP)
        }
        
        return result
    }
    
    func maxFittingProfit(forWorker worker: Int, inDifficulties difficulties: [Int], withProfits profits: [Int]) -> Int
    {
        var lower = 0, upper = difficulties.count - 1
        var i = profits.count / 2
        while (lower <= upper) {
            if difficulties[i] > worker {
                upper = i - 1
                i = (lower + upper) / 2
            }
            else if (i != difficulties.count - 1) && (difficulties[i+1] <= worker) {
                lower = i + 1
                i = (lower + upper) / 2
            }
            else {
                return profits[i]
            }
        }
        return 0
    }
}

---

620ms

class Solution {
    func binarySearch(_ difficulty: inout [Int], _ worker: Int) -> Int? {
        if difficulty.count == 0 || difficulty[0] > worker {
            return nil
        }
        
        var left = 0, right = difficulty.count - 1
        while left < right {
            let mid = left + (right - left) / 2
            if worker >= difficulty[mid] &&
                worker < difficulty[mid + 1] {
                return mid
            }
            
            if worker > difficulty[mid] {
                left = mid + 1
            } else {
                right = mid
            }
        }
        
        return left
    }
    
    func maxProfitAssignment(_ difficulty: [Int], _ profit: [Int], _ worker: [Int]) -> Int {
        var p = 0
        
        let ed = difficulty.enumerated().sorted(by: { $0.element < $1.element })
        var dp = [Int: Int]()
        var maxp = 0
        for (index, d) in ed {
            maxp = max(maxp, profit[index])
            dp[d] = maxp
        }

        var d = difficulty.sorted()
        for w in worker {
            let di = binarySearch(&d, w)
            if let di = di {
                p += dp[d[di]]!
            }
        }        
        return p
    }
}

---

628ms

class Solution {
    func maxProfitAssignment(_ difficulty: [Int], _ profit: [Int], _ worker: [Int]) -> Int {
        var jobs = [Int: Int]() // [Difficulty, Profit]
        for i in 0..<difficulty.count {
            let d = difficulty[i]
            if let existing = jobs[d] {
                jobs[d] = max(existing, profit[i])
            } else {
                jobs[d] = profit[i]
            }
        }
        let sorted = jobs.sorted { (a, b) -> Bool in
            if a.value == b.value {
                return a.key > b.key
            } else {
                return a.value > b.value
            }
        }
        var current = 0        
        let worker = worker.sorted().reversed()        
        var maxProfit = 0
        
        for w in worker {
            while current < sorted.count, sorted[current].key > w {
                current += 1
            }
            
            if current == sorted.count {
                return maxProfit
            } else {
                maxProfit += sorted[current].value
            }
        }        
        return maxProfit
    }
}

---

Runtime: 668 ms

Memory Usage: 20.1 MB

class Solution {
    func maxProfitAssignment(_ difficulty: [Int], _ profit: [Int], _ worker: [Int]) -> Int {
        var res:Int = 0
        var n:Int = profit.count
        var dp:[Int] = [Int](repeating:0,count:100001)
        for i in 0..<n
        {
            dp[difficulty[i]] = max(dp[difficulty[i]], profit[i])
        }
        for i in 1..<dp.count
        {
            dp[i] = max(dp[i], dp[i - 1])
        }
        for ability in worker
        {
            res += dp[ability]
        }
        return res
    }
}

---

772ms

class Solution {
    func maxProfitAssignment(_ difficulty: [Int], _ profit: [Int], _ worker: [Int]) -> Int {
        var max = 0 as Int        
        let count = difficulty.count

        var sortedCache = [[Int]:Int]()
        for i in 0...count-1{
            sortedCache[[difficulty[i],i]] = profit[i]
        }
        
        var difficulty_ = sortedCache.keys.sorted{
            return $0[0] < $1[0]
        }
        
        var maxProfitCache = [Int:Int]()
        var sortedMPKeys = [Int]()        
        var runningMaxProfit = 0
        
        for i in 0...count-1{
            
            let nextK = difficulty_[i]
            let dif = nextK[0]
            var profit = sortedCache[nextK] as! Int
        
            var nextMax = maxProfitCache[dif] ?? 0
            let nextMax_ = nextMax
            
            if runningMaxProfit > profit{
                profit = runningMaxProfit    
            }
            
            if profit > nextMax{
                
                runningMaxProfit = profit
                nextMax = profit
                maxProfitCache[dif] = nextMax
                
                if nextMax_ == 0{
                    sortedMPKeys.append(dif)
                }
            }                
        }
        
        sortedMPKeys = sortedMPKeys.sorted()
        
        for w in worker{
            var maxW = 0 as Int
            let index = binarySearch(sortedMPKeys, key: w, range: 0 ..< sortedMPKeys.count)
            if index != nil && index! >= 0{
                maxW = maxProfitCache[sortedMPKeys[index!]]!
            }else if index == nil && index != -1{
                maxW = maxProfitCache[sortedMPKeys.last!]!
            }

            max += maxW
        }
        return max
    }
}

func binarySearch<T: Comparable>(_ a: [T], key: T, range: Range<Int>) -> Int? {
    return _binarySearch(a, key: key, range: range, -1)
}

func _binarySearch<T: Comparable>(_ a: [T], key: T, range: Range<Int>, _ maxIdxResult : Int) -> Int? {
    
    var maxIdxResult = maxIdxResult
    
    if range.lowerBound >= range.upperBound {
        return maxIdxResult

    } else {
        let midIndex = range.lowerBound + (range.upperBound - range.lowerBound) / 2
        if a[midIndex] > key {
            return _binarySearch(a, key: key, range: range.lowerBound ..< midIndex,maxIdxResult)
        } else if a[midIndex] < key {
            maxIdxResult = midIndex
            return _binarySearch(a, key: key, range: midIndex + 1 ..< range.upperBound,maxIdxResult)
        } else {
            return midIndex
        }
    }
}

func println(_ format : String, _ args : CVarArg...) {
    let s = String.init(format: format, arguments: args)
    print(s, separator: "", terminator: "\n")
}