1889. 装包裹的最小浪费空间Java

文章发布较早，内容可能过时，阅读注意甄别。

# 题目

给你 n 个包裹，你需要把它们装在箱子里，每个箱子装一个包裹。总共有 m 个供应商提供不同尺寸的箱子（每个规格都有无数个箱子）。如果一个包裹的尺寸小于等于一个箱子的尺寸，那么这个包裹就可以放入这个箱子之中。

包裹的尺寸用一个整数数组 packages 表示，其中 packages[i] 是第 i 个包裹的尺寸。供应商用二维数组 boxes 表示，其中 boxes[j] 是第 j 个供应商提供的所有箱子尺寸的数组。

你想要选择一个供应商并只使用该供应商提供的箱子，使得总浪费空间最小。对于每个装了包裹的箱子，我们定义浪费的空间等于箱子的尺寸 - 包裹的尺寸。总浪费空间为所有箱子中浪费空间的总和。

比方说，如果你想要用尺寸数组为 [4,8] 的箱子装下尺寸为 [2,3,5] 的包裹，你可以将尺寸为 2 和 3 的两个包裹装入两个尺寸为 4 的箱子中，同时把尺寸为 5 的包裹装入尺寸为 8 的箱子中。总浪费空间为 (4-2) + (4-3) + (8-5) = 6 。请你选择最优箱子供应商，使得总浪费空间最小。如果无法将所有包裹放入箱子中，请你返回 -1 。由于答案可能会很大，请返回它对 109 + 7 取余的结果。

示例 1：

输入：packages = [2,3,5], boxes = [[4,8],[2,8]]
输出：6
解释：选择第一个供应商最优，用两个尺寸为 4 的箱子和一个尺寸为 8 的箱子。
总浪费空间为 (4-2) + (4-3) + (8-5) = 6 。

示例 2：

输入：packages = [2,3,5], boxes = [[1,4],[2,3],[3,4]]
输出：-1
解释：没有箱子能装下尺寸为 5 的包裹。

示例 3：

输入：packages = [3,5,8,10,11,12], boxes = [[12],[11,9],[10,5,14]]
输出：9
解释：选择第三个供应商最优，用两个尺寸为 5 的箱子，两个尺寸为 10 的箱子和两个尺寸为 14 的箱子。
总浪费空间为 (5-3) + (5-5) + (10-8) + (10-10) + (14-11) + (14-12) = 9 。

提示：

n == packages.length
m == boxes.length
1 <= n <= 105
1 <= m <= 105
1 <= packages[i] <= 10⁵
1 <= boxes[j].length <= 10⁵
1 <= boxes[j][k] <= 10⁵
sum(boxes[j].length) <= 10⁵
boxes[j] 中的元素互不相同。

# 思路

注意 sum(boxes[j].length) <= 10^5 这个, 就能很明显发觉是二分

# 解法

class Solution {
    public int minWastedSpace(int[] packages, int[][] boxes) {
        int len = packages.length, mod = (int) 1e9 + 7;
        Arrays.sort(packages);
        long[] res = new long[]{Long.MAX_VALUE, Long.MAX_VALUE};
        for (int i = 0; i < boxes.length; i++) {
            long[] m = new long[2];
            int start = -1;
            Arrays.sort(boxes[i]);
            if (boxes[i][boxes[i].length-1] < packages[len-1]) continue;
            for (int j = 0; j < boxes[i].length && start < len-1; j++) {
                int l = -1, r = len-1, mid = r / 2;
                while (mid >= 0 && l < r) {
                    if (boxes[i][j] >= packages[mid]) {
                        l = mid;
                    } else {
                        r = mid - 1;
                    }
                    mid = l + (r - l + 1) / 2;
                }
                if (l > start) {
                    long t = ((long) (l - start) * boxes[i][j]);
                    m[0] += ((m[1] + t) / mod);
                    m[1] = (m[1] + t) % mod;
                    start = l;
                }
            }
            if (m[0] < res[0] || (m[0] == res[0] && m[1] < res[1])) {
                res = m;
            }
        }
        if (res[1] == Long.MAX_VALUE) return -1;
        long nums = 0;
        for (int aPackage : packages) {
            nums = (nums + aPackage) % mod;
        }
        long f = res[1] - nums;
        return (int) (f < 0 ? f + mod : f);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# 总结

分析出几种情况，然后分别对各个情况实现

#Java