1889. Minimum Space Wasted From Packaging

Description

You have n packages that you are trying to place in boxes, one package in each box. There are m suppliers that each produce boxes of different sizes (with infinite supply). A package can be placed in a box if the size of the package is less than or equal to the size of the box.

The package sizes are given as an integer array packages, where packages[i] is the size of the ith package. The suppliers are given as a 2D integer array boxes, where boxes[j] is an array of box sizes that the jth supplier produces.

You want to choose a single supplier and use boxes from them such that the total wasted space is minimized. For each package in a box, we define the space wasted to be size of the box - size of the package. The total wasted space is the sum of the space wasted in all the boxes.

• For example, if you have to fit packages with sizes [2,3,5] and the supplier offers boxes of sizes [4,8], you can fit the packages of size-2 and size-3 into two boxes of size-4 and the package with size-5 into a box of size-8. This would result in a waste of (4-2) + (4-3) + (8-5) = 6.

Return the minimum total wasted space by choosing the box supplier optimally, or -1 if it is impossible to fit all the packages inside boxes. Since the answer may be large, return it modulo 109 + 7.

 

Example 1:

Input: packages = [2,3,5], boxes = [[4,8],[2,8]]
Output: 6
Explanation: It is optimal to choose the first supplier, using two size-4 boxes and one size-8 box.
The total waste is (4-2) + (4-3) + (8-5) = 6.

Example 2:

Input: packages = [2,3,5], boxes = [[1,4],[2,3],[3,4]]
Output: -1
Explanation: There is no box that the package of size 5 can fit in.

Example 3:

Input: packages = [3,5,8,10,11,12], boxes = [[12],[11,9],[10,5,14]]
Output: 9
Explanation: It is optimal to choose the third supplier, using two size-5 boxes, two size-10 boxes, and two size-14 boxes.
The total waste is (5-3) + (5-5) + (10-8) + (10-10) + (14-11) + (14-12) = 9.

 

Constraints:

• n == packages.length
• m == boxes.length
• 1 <= n <= 105
• 1 <= m <= 105
• 1 <= packages[i] <= 105
• 1 <= boxes[j].length <= 105
• 1 <= boxes[j][k] <= 105
• sum(boxes[j].length) <= 105
• The elements in boxes[j] are distinct.

 

Solutions

Solution: Prefix Sum + Binary Search

• Time complexity: O(nlogn+mlogm+mlogn)
• Space complexity: O(n)

 

JavaScript

/**
 * @param {number[]} packages
 * @param {number[][]} boxes
 * @return {number}
 */
const minWastedSpace = function (packages, boxes) {
  const MODULO = BigInt(10 ** 9 + 7);
  const n = packages.length;
  const prefixSum = Array.from({ length: n + 1 }, () => 0n);
  let result = -1;

  const findPackage = (left, box) => {
    let right = n - 1;

    while (left <= right) {
      const mid = Math.floor((left + right) / 2);

      packages[mid] > box ? (right = mid - 1) : (left = mid + 1);
    }

    return right;
  };

  packages.sort((a, b) => a - b);

  for (let index = 1; index <= n; index++) {
    prefixSum[index] = prefixSum[index - 1] + BigInt(packages[index - 1]);
  }

  for (const supplier of boxes) {
    supplier.sort((a, b) => a - b);

    if (supplier.at(-1) < packages[n - 1]) continue;

    let left = 0;
    let wasted = 0n;

    for (const box of supplier) {
      const index = findPackage(left, box);

      if (index < left) continue;
      const boxCount = BigInt(index - left + 1);
      const totalBoxSizes = BigInt(box) * boxCount;
      const totalPackages = prefixSum[index + 1] - prefixSum[left];

      wasted = wasted + totalBoxSizes - totalPackages;
      left = index + 1;
    }

    if (result === -1 || wasted < result) {
      result = wasted;
    }
  }

  return Number(BigInt(result) % MODULO);
};