[Swift]LeetCode1011. 在 D 天内送达包裹的能力 | Capacity To Ship Packages Within D Days

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

A conveyor belt has packages that must be shipped from one port to another within D days.

The i-th package on the conveyor belt has a weight of weights[i].  Each day, we load the ship with packages on the conveyor belt (in the order given by weights). We may not load more weight than the maximum weight capacity of the ship.

Return the least weight capacity of the ship that will result in all the packages on the conveyor belt being shipped within D days. 

Example 1:

Input: weights = [1,2,3,4,5,6,7,8,9,10], D = 5
Output: 15
Explanation: 
A ship capacity of 15 is the minimum to ship all the packages in 5 days like this:
1st day: 1, 2, 3, 4, 5
2nd day: 6, 7
3rd day: 8
4th day: 9
5th day: 10

Note that the cargo must be shipped in the order given, so using a ship of capacity 14 and splitting the packages into parts like (2, 3, 4, 5), (1, 6, 7), (8), (9), (10) is not allowed. 

Example 2:

Input: weights = [3,2,2,4,1,4], D = 3
Output: 6
Explanation: 
A ship capacity of 6 is the minimum to ship all the packages in 3 days like this:
1st day: 3, 2
2nd day: 2, 4
3rd day: 1, 4

Example 3:

Input: weights = [1,2,3,1,1], D = 4
Output: 3
Explanation: 
1st day: 1
2nd day: 2
3rd day: 3
4th day: 1, 1 

Note:

1. 1 <= D <= weights.length <= 50000
2. 1 <= weights[i] <= 500

---

Runtime: 276 ms

Memory Usage: 19.8 MB

class Solution {
    func shipWithinDays(_ weights: [Int], _ D: Int) -> Int {
        var lo:Int = weights[0]
        var hi:Int = 0
        for i in 0..<weights.count
        {
            lo = max(weights[i], lo)
            hi += weights[i]
        }
        while (lo < hi)
        {
            var mid:Int = (hi+lo)/2
            if can(weights, D, mid)
            {
                hi = mid
            }
            else
            {
                lo = mid + 1
            }
        }
        return lo        
    }
    
    func can(_ weights: [Int], _ D: Int,_ cap:Int) -> Bool
    {
        var cd:Int = 0
        var ans:Int = 1
        for i in 0..<weights.count
        {
            if cd + weights[i] > cap
            {
                ans += 1
                cd = 0
            }
            cd += weights[i]
        }
        return ans <= D        
    }
}

---

456ms 

class Solution {
    func shipWithinDays(_ weights: [Int], _ D: Int) -> Int {
        let sum = weights.reduce(0) { $0 + $1 }
        var left = sum / D
        var right = sum
        
        while right - left > 1 {
            let mid = (right - left) / 2 + left
            let result = canShip(weights, D, c: mid)
            
            if result {
                right = mid
            } else {
                left = mid + 1
            }
        }
        
        return canShip(weights, D, c: left) ? left : right
    }
    
    private func canShip(_ weights: [Int], _ D: Int, c: Int) -> Bool {
        var current = 0
        var days = 1
        
        for weight in weights {
            if weight > c {
                return false
            } else if current + weight > c {
                days += 1
                current = weight
            } else {
                current = current + weight
            }
            
            if days > D {
                return false
            }
        }
        
        return true
    }
}

---

460ms

class Solution {
    func shipWithinDays(_ weights: [Int], _ D: Int) -> Int {
        // Binary serach on range [max value in array, sum]
        
        if weights.count == 0 { return 1 }
        
        var sum = 0
        var maxVal = Int.min
        
        for weight in weights {
            sum += weight
            maxVal = max(maxVal, weight)
        }
        
        var left = maxVal, right = sum
        
        
        while left < right {
            let W = (left + right) / 2
            
            if canSuccess(weights, D, W) {
                right = W
            } else {
                left = W + 1
            }
            
        }
        
        return max(right, 1)
    }
    
    /*
     * Checking if the task can be done with current res
     *
     */
    private func canSuccess(_ weights:[Int], _ D: Int, _ W: Int) -> Bool {
        var curWeight = 0
        var curDay = 0
        
        
        for weight in weights {
            if curWeight + weight > W {
                curDay += 1
                curWeight = weight
            } else {
                curWeight += weight
            }
            
            if curDay > D { return false }
        }
        
        if curWeight > 0 { curDay += 1 }

        return curDay <= D
        
    }
}

---

464ms

class Solution {
    func shipWithinDays(_ weights: [Int], _ D: Int) -> Int {  
        let maxv = weights.max()!, sum = weights.reduce(0, +)
        var left = max(sum/weights.count, maxv), right = sum
        var ans = right
        var curCap = ans, curDayCost = 0
        while left < right {
            let midv = (left+right)/2
            curCap = midv; curDayCost = 1
            for w in weights {
                if curCap < w {
                    curCap = midv; curDayCost += 1
                }
                curCap -= w
            }

            if curDayCost <= D {
                ans = midv
                right = midv
            }
            else {
                left = midv+1
            }
        }
        return ans
    }
}

---

476ms

class Solution {
    func shipDay(weights: [Int], capacity: Int) -> Int {
        var current = 0, result = 0
        
        for weight in weights {
            if current + weight > capacity {
                current = weight
                result += 1
            } else {
                current += weight
            }
        }
        
        if current != 0 {
            result += 1
        }
        return result
    }
    func shipWithinDays(_ weights: [Int], _ D: Int) -> Int {
        var start = weights.reduce(Int.min, max), end = weights.reduce(0, +)
        
        while start != end {
            let mid = (start + end) / 2
            if shipDay(weights: weights, capacity: mid) > D {
                start = mid + 1
            } else {
                end = mid
            }
        }
        
        return start
    }
}