Capacity To Ship Packages Within D Days LT1011

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

Idea 1. Start with easy case, assume d = 2, it means splitting the array in two parts so that the maximum sum of continuous subarray is the minimal, given example

weights = [3,2,2,4,1,4], D = 2, n = 6
k = 0, dp(0, 5) = max(prefix(0, 0), dp(1, 5)(1)) = max(3, 13) = 13 
k = 1, dp(0, 5) = max(prefix(0, 1), dp(2, 5)(1)) = max(5, 11) = 11
k = 2, dp(0, 5) = max(prefix(0, 2), dp(3, 5)(1)) = max(7, 9) = 9
k = 3, dp(0, 5) = max(prefix(0, 3), dp(4, 5)(1)) = max(11, 5) = 11
k = 4, dp(0, 5) = max(prefix(0, 4), dp(5, 5)(1)) = max(12, 4) = 12
dp(0, 5) = min(13, 11, 9, 11, 12) = 9,splitting the array from k = 2, [3, 2, 2], [4,1,4] achieving the minimum load 9.

how about d = 3? 
k = 0, dp(0, 5) = max(prefix(0, 0), dp(1, 5)(d=2)) = max(3, 8) = 8
k = 1, dp(0, 5) = max(prefix(0, 1), dp(2, 5)(d=2)) = max(5, 6) = 6
k = 2, dp(0, 5) = max(prefix(0, 2), dp(3, 5)(d=2)) = max(7, 5) = 7
k = 3, dp(0, 5) = max(prefix(0, 3), dp(4, 5)(d=2)) = max(11, 4) = 11
dp(0, 5)(3) = min(8, 6, 7, 11) = 6

spliting the array from position k, if put all loads from weights(i, k) as the first day, weights(k+1, j) requires to be loaded within d-1 days, another subproblems, the relationship can be respresented as the formula, let dp(i, j)(d) be the minimum loads in d days:

dp(i, j)(d) = min(i<=k <= j-d+1)( max( prefix(i, k), dp(k+1, j)(d-1)) ))

如果某一段weights[i, j]用一天，需要计算subarray sum, 用一个prefixSum数组提前计算好

Time complexity: O(n3)

Space complexity: O(n2)

    private int calculateMinCapacity(int i, int j, int d,
                                      int[] prefixSum, int[][] dp) {
         int minCapacity = Integer.MAX_VALUE;

         for(int k = i; k <= j-d+1; ++k) {
             int next = ((d == 2)? prefixSum[j+1] - prefixSum[k+1] : dp[k+1][j]);
             int val = Math.max(prefixSum[k+1] - prefixSum[i], next);
             minCapacity = Math.min(minCapacity, val);
         }
         return minCapacity;
     }

     public int shipWithinDays(int[] weights, int D) {
         int n = weights.length;
         int[] prefixSum = new int[n+1];
         for(int i = 1; i <= n; ++i) {
             prefixSum[i] = prefixSum[i-1] + weights[i-1];
         }

         int[][] dp = new int[n][n];

         if(D == 1) {
             return prefixSum[n];
         }

         for(int d = 2; d <= D; ++d) {
             for(int i = 0; i < n; ++i) {
                 for(int j = i+d-1; j < n; ++j) {
                 //for(int j = n-1; j>= i+d-1; --j) {
                     dp[i][j] = calculateMinCapacity(i, j, d, prefixSum, dp);
                 }
             }
         }
         return dp[0][n-1];
     }

Idea 1.b. 从上面的公式可以看出j是固定的n-1, 可以变成一维的dp

dp(i)(d) = min(i <= k <= j-d+1)(max(prefixSum(i, k), dp(k+1)(d-1)))

Time complexity: O(n2)

Space complexity: O(n)

 class Solution {
     private int calculateMinCapacity(int i,int d,
                                      int[] prefixSum, int[] dp) {
         int minCapacity = Integer.MAX_VALUE;
         int n = dp.length;
         for(int k = i; k <= n-d; ++k) {
             int next = ((d == 2)? prefixSum[n] - prefixSum[k+1] : dp[k+1]);
             int val = Math.max(prefixSum[k+1] - prefixSum[i], next);
             minCapacity = Math.min(minCapacity, val);
         }
         return minCapacity;
     }

     public int shipWithinDays(int[] weights, int D) {
         int n = weights.length;
         int[] prefixSum = new int[n+1];
         for(int i = 1; i <= n; ++i) {
             prefixSum[i] = prefixSum[i-1] + weights[i-1];
         }

         if(D == 1) {
             return prefixSum[n];
         }
         if(D == n) {
             return Arrays.stream(weights).max().getAsInt();
         }

         int[] dp = new int[n];
         for(int d = 2; d <= D; ++d) {
             for(int i = 0; i <= n-d; ++i) {
                     dp[i]= calculateMinCapacity(i, d, prefixSum, dp);
                 }
             }

         return dp[0];
     }
 }

Idea 2. 啊 竟然有binary search的妙法。确定search space: [max(weights[i]), sum(weights[i])], 这题是求

least weigth capacity, 即使找到第一个满足D days的weight, 不确定是否更小的也满足条件，所以要继续包括在search space中，就像寻找有duplicates的数组里第一个等于目标的index 还有网上看到的优化, 最小值设为max(sum(weights[i])/D, max(weights[i])), 如果数组里有很多小数，这个可以进一步的narrow down search space.

Note: 1. 特别容易混淆== 放哪边，days > D, move the search space to the rights, as the searched mid load is too small and it takes more days to finish the load, rule out mid load, move the search space from mid+1

　　  days <= D, even it's == D, there might be smaller load like mid-1 or mid-2 satisfy the conidition, move the search space to the right, upperbounded by mid, similar direction as the mid load is too large and it takes less days to finish the load and continue to seach the smaller load.

　　　2. sum + weight > load, 这个包括当前sum == load, 在前面sum的时候分割, 天数比分割数多一，初始化days=1, 这2个细节谨记　

Time complexity: nlog(mn), n is the length of weights, m is the maximum elements in weights,  checkdays takes n steps, which is executed during each binary search in the range(max(weights), sum(weights)).

Space complexity: O(1)

 class Solution {
     private int checkDays(int[] weights, int load) {
         int sum = 0;
         int days = 1;
         for(int weight: weights) {
             if(sum + weight > load) {
                 ++days;
                 sum = weight;
             }
             else {
                 sum += weight;
             }
         }

         return days;
     }

     public int shipWithinDays(int[] weights, int D) {
       int n = weights.length;
       int minLoad = 0, maxLoad = 0;
       for(int weight: weights) {
           minLoad = Math.max(minLoad, weight);
           maxLoad += weight;
       }

       if(D == 1) {
           return maxLoad;
       }
       if(D >= n) {
           return minLoad;
       }

       while(minLoad < maxLoad) {
           int mid = minLoad + (maxLoad - minLoad)/2;
           int days = checkDays(weights, mid);
           if(days > D) {
               minLoad = mid + 1;
           }
           else {
               maxLoad = mid;
           }
       }

       return minLoad;
     }
 }