干tm的算法4:在 D 天内送达包裹的能力

传送带上的包裹必须在 D 天内从一个港口运送到另一个港口。

传送带上的第 i 个包裹的重量为 weights[i]。每一天，我们都会按给出重量的顺序往传送带上装载包裹。我们装载的重量不会超过船的最大运载重量。

返回能在 D 天内将传送带上的所有包裹送达的船的最低运载能力。

 

示例 1：

输入：weights = [1,2,3,4,5,6,7,8,9,10], D = 5
输出：15
解释：
船舶最低载重 15 就能够在 5 天内送达所有包裹，如下所示：
第 1 天：1, 2, 3, 4, 5
第 2 天：6, 7
第 3 天：8
第 4 天：9
第 5 天：10

请注意，货物必须按照给定的顺序装运，因此使用载重能力为 14 的船舶并将包装分成 (2, 3, 4, 5), (1, 6, 7), (8), (9), (10) 是不允许的。 
示例 2：

输入：weights = [3,2,2,4,1,4], D = 3
输出：6
解释：
船舶最低载重 6 就能够在 3 天内送达所有包裹，如下所示：
第 1 天：3, 2
第 2 天：2, 4
第 3 天：1, 4
示例 3：

输入：weights = [1,2,3,1,1], D = 4
输出：3
解释：
第 1 天：1
第 2 天：2
第 3 天：3
第 4 天：1, 1
 

提示：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/capacity-to-ship-packages-within-d-days
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

老哥的代码

class Solution {
    public int shipWithinDays(int[] weights, int D) {
        /*
            要在 D 天内运完所有包裹，那么每天至少的承载量为 sum / D
            但是，因为一次至少运 1 个包裹，而这个包裹的重量可大可小，那么可能 weights[i] > sum / D
            假设包裹最大的重量为 maxWeight
            因此，最低承载量应该为 capacity = max(sum / D, maxWeight);

            最直接的方法，就是直接从 capacity 开始，每次 capacity++ 进行尝试，但这样效率很低
            因此我们可以使用二分查找， left = capacity， right = sum，即最低承载量为 capacity,最高的承载量为 包裹总量
            我们判断承载量 mid 是否能在 D 天内装完（无需刚好 D 天，只需要 [1, D] 即可），如果不能，表示承载量太小，则 left = mid + 1，否则 right = mid
            因为必定存在一个答案，因此当退出循环， left = right 时，就是答案
        */
        int len = weights.length;
        int sum = 0;
        int max = 0;
        for(int num : weights){
            sum += num;
            max = Math.max(max, num);
        }
        //最低承载量
        int left = Math.max(sum / D, max);
        //最高承载量
        int right = sum;
        while(left < right){
            int mid = (left + right) >>> 1;
            //容量为 mid 是否可行，如果不可行，表示 mid 过小
            if(isOk(weights, mid, D)){
                right = mid;
            }else{
                left = mid + 1;
            }
        }
        return left;
    }
    //判断以 capa 作为容量是否能够在 D 天内装完
    private boolean isOk(int[] weights, int capa, int D){
        int temp = 0;
        for(int val : weights){
            if(temp + val > capa){
                temp = 0;
                D--;
            }
            temp += val;
        }
        return D > 0;
    }
}

题目最开始我做了分析。首先是最小运载应该是，加起来的重量之和/可以用到的天数。也就是假设数量可以均分的话。可以得到一个最小值AVG(SUM)。其实是这组数据的单个值最大是多少。因为这里不能均分，单个值为max。这里的最大值应该是数量之和 SUM。
所以正确答案应该是 （ [AVG(SUM) > max ? AVG(SUM):max ]，SUM）
不过我最开始想到的是递增，就是从最小值开始，一步步校验到最大值。
不过上面老哥给的想法就很好，二分法。因为上述想法中我们可以得到一个区间范围的数据，对数据进行二分处理，知道左边跟右边的值重合，那么这个数据就是我们的题目里面的最终答案。
以及对应判断该数值是否满足题目要求。大意是对重量数组进行 单个单个累加，如果累加数量之和大于我们给出的最小数量，那么就假定这个数量之前的作为一天的运载量，然后当前累加这个数量作为本次起始累计数量，进行下一天的运载处理，对应时间需要减去1。直到最后运往时候，原先假定的天数经过我们多次的-- 处理，是否依然大于0，注意 因为这里用的是D-- ，所以算到最后 D应该是保留1的 ，所以这里用D>0 ,而不是D>=0;

官方思路 好像没官方的答案，那么本题选用点赞最高的

方法一：二分查找
思路：
对于一艘承载力为K船来说，我们必然会在不超过其承载力的前提下贪心地往上装载货物，这样才能使得运送包裹所花费的时间最短。
如果船在承载力为K的条件下可以完成在D天内送达包裹的任务，那么任何承载力大于K的条件下依然也能完成任务。
我们可以让这个承载力K从max(weights)max(weights)开始（即所有包裹中质量最大包裹的重量，低于这个重量我们不可能完成任务），逐渐增大承载力K，直到K可以让我们在D天内送达包裹。此时K即为我们所要求的最低承载力。
逐渐增大承载力K的方法效率过低，让我们用二分查找的方法来优化它。
相似题目：
875. 爱吃香蕉的珂珂

算法：
定义函数canShip(D, K)canShip(D,K),来判断在最低承载力为KK的情形下能否在DD天内送达所有包裹。我们所要做的就是按照传送带上货物的顺序，依次且尽可能多地往船上装载货物，当该艘船无法装下更多货物时，我们换一搜船，同时将天数加11。当运输完所有货物后，我们判断所用的天数是否小于等于DD。
用二分查找的方式，来查找这个最低承载力，如果midmid可以完成任务，我们把查找范围缩减至[lo, mid][lo,mid]（注意不是mid+1mid+1,因为midmid可能是我们所求的解），否则我们去[mid+1, hi][mid+1,hi]区间中继续查找，详情见代码。

作者：KLEA
链接：https://leetcode-cn.com/problems/capacity-to-ship-packages-within-d-days/solution/zai-dtian-nei-song-da-bao-guo-de-neng-li-by-lenn12/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

class Solution {
    public int shipWithinDays(int[] weights, int D) {
        int lo = 0, hi = Integer.MAX_VALUE;
        while (lo < hi) {
        	int mid = lo + (hi - lo) / 2;
        	if (canShip(weights, D, mid)) {
        		hi = mid;
        	} else {
        		lo = mid+1;
        	}
        }
        return lo;
    }
    private boolean canShip(int[] weights, int D, int K) {
    	int cur = K; // cur 表示当前船的可用承载量
    	for (int weight: weights) {
    		if (weight > K) return false;
    		if (cur < weight) {
    			cur = K;
    			D--;
    		}
    		cur -= weight;
    	}
    	return D > 0; // 能否在D天内运完
    }
}

复杂度分析：
时间复杂度：O(NlogN)O(NlogN)
空间复杂度：O(1)O(1)

另外发现一个小窍门 你点击提交之后，可以看到不同时段的优秀答题。

具体代码如下:

class Solution {
    public int shipWithinDays(int[] weights, int D) {
        if (D == 1) {
            int sum = 0;
            for (int weight : weights) {
                sum += weight;
            }
            return sum;
        }
        int sum = 0, max = 0;
        for (int weight : weights) {
            sum += weight;
            max = Math.max(max, weight);
        }
        int l = max, r = (max * weights.length - 1)/ D + 1, res = -1;
        while(l <= r) {
            int mid = l + ((r - l) >> 1);
            if (check(weights, D, mid)) {
                res = mid;
                r = mid - 1;
            } else {
                l = mid + 1;
            }
        }
        return res;
    }

    private boolean check(int[] weights, int D, int pWieght) {
        int cur = 0, count = 0;
        for (int weight : weights) {
            if (cur + weight > pWieght) {
                cur = 0;
                count++;
                if (count > D) {
                    return false;
                }
            }
            cur += weight;
        }
        if (cur > 0) {
            count++;
        }
        return count <= D;
    }
}

思维决定解题，慢慢吸收优秀的解题思路，提升自己。

---

漫漫长路，一个小周跟他一个小陈朋友一起努力奔跑。

---