1889

1889. Minimum Space Wasted From Packaging (Hard)

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.

Companies:
Amazon

Related Topics:
Binary Search

Solution 1. Prefix Sum

// OJ: https://leetcode.com/problems/minimum-space-wasted-from-packaging/
// Author: github.com/lzl124631x
// Time: O(PlogP + BlogB)
// Space: O(max(P))
class Solution {
public:
    int minWastedSpace(vector<int>& P, vector<vector<int>>& B) {
        long mod = 1e9 + 7, ans = LONG_MAX, N = P.size(), sum[100001] = {}, cnt[100001] = {};
        sort(begin(P), end(P));
        for (int i = 1, j = 0; i < 100001; ++i) {
            sum[i] = sum[i - 1];
            cnt[i] = cnt[i - 1];
            while (j < N && P[j] == i) {
                sum[i] += i;
                cnt[i]++;
                ++j;
            }
        }
        for (auto &b : B) {
            sort(begin(b), end(b));
            if (b.back() < P.back()) continue;
            long tmp = 0, prev = 0;
            for (int i = 0; i < b.size(); ++i) {
                tmp += (cnt[b[i]] - cnt[prev]) * b[i] - (sum[b[i]] - sum[prev]);
                prev = b[i];
            }
            ans = min(ans, tmp);
        }
        return ans == LONG_MAX ? -1 : ans % mod;
    }
};

Solution 2. Binary Search

// OJ: https://leetcode.com/problems/minimum-space-wasted-from-packaging/
// Author: github.com/lzl124631x
// Time: O(PlogP + BlogB + BlogP)
// Space: O(P)
class Solution {
public:
    int minWastedSpace(vector<int>& P, vector<vector<int>>& B) {
        long mod = 1e9 + 7, ans = LONG_MAX, N = P.size();
        sort(begin(P), end(P));
        vector<long> sum(N + 1);
        for (int i = 0; i < N; ++i) sum[i + 1] = sum[i] + P[i];
        for (auto &b : B) {
            sort(begin(b), end(b));
            if (b.back() < P.back()) continue;
            long tmp = 0, prev = 0;
            for (int i = 0; i < b.size(); ++i) {
                int cur = upper_bound(begin(P) + prev, end(P), b[i]) - begin(P);
                tmp += (cur - prev) * b[i] - (sum[cur] - sum[prev]);
                prev = cur;
            }
            ans = min(ans, tmp);
        }
        return ans == LONG_MAX ? -1 : ans % mod;
    }
};

The prefix sum array is actually not necessary.

// OJ: https://leetcode.com/problems/minimum-space-wasted-from-packaging/
// Author: github.com/lzl124631x
// Time: O(PlogP + BlogB + BlogP)
// Space: O(1)
class Solution {
public:
    int minWastedSpace(vector<int>& P, vector<vector<int>>& B) {
        long mod = 1e9 + 7, ans = LONG_MAX, N = P.size(), sum = accumulate(begin(P), end(P), 0L);
        sort(begin(P), end(P));
        for (auto &b : B) {
            sort(begin(b), end(b));
            if (b.back() < P.back()) continue;
            long tmp = 0, prev = 0;
            for (int i = 0; i < b.size(); ++i) {
                int cur = upper_bound(begin(P) + prev, end(P), b[i]) - begin(P);
                tmp += (cur - prev) * b[i];
                prev = cur;
            }
            ans = min(ans, tmp - sum);
        }
        return ans == LONG_MAX ? -1 : ans % mod;
    }
};