+ problem 1889

fruit-in · fruit-in · commit 23645fbc63a1 · 2025-04-16T21:23:07.000+08:00
diff --git a/Problemset/1889-Minimum Space Wasted From Packaging/README.md b/Problemset/1889-Minimum Space Wasted From Packaging/README.md
@@ -0,0 +1,76 @@
+# 1889. Minimum Space Wasted From Packaging
+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 <code>i<sup>th</sup></code> package. The suppliers are given as a 2D integer array `boxes`, where `boxes[j]` is an array of **box sizes** that the <code>j<sup>th</sup></code> 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** <code>10<sup>9</sup> + 7</code>.
+
+#### Example 1:
+<pre>
+<strong>Input:</strong> packages = [2,3,5], boxes = [[4,8],[2,8]]
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> 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.
+</pre>
+
+#### Example 2:
+<pre>
+<strong>Input:</strong> packages = [2,3,5], boxes = [[1,4],[2,3],[3,4]]
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> There is no box that the package of size 5 can fit in.
+</pre>
+
+#### Example 3:
+<pre>
+<strong>Input:</strong> packages = [3,5,8,10,11,12], boxes = [[12],[11,9],[10,5,14]]
+<strong>Output:</strong> 9
+<strong>Explanation:</strong> 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.
+</pre>
+
+#### Constraints:
+* `n == packages.length`
+* `m == boxes.length`
+* <code>1 <= n <= 10<sup>5</sup></code>
+* <code>1 <= m <= 10<sup>5</sup></code>
+* <code>1 <= packages[i] <= 10<sup>5</sup></code>
+* <code>1 <= boxes[j].length <= 10<sup>5</sup></code>
+* <code>1 <= boxes[j][k] <= 10<sup>5</sup></code>
+* <code>sum(boxes[j].length) <= 10<sup>5</sup></code>
+* The elements in `boxes[j]` are **distinct**.
+
+## Solutions (Python)
+
+### 1. Solution
+```Python
+class Solution:
+    def minWastedSpace(self, packages: List[int], boxes: List[List[int]]) -> int:
+        prefixsum = [0] * (len(packages) + 1)
+        ret = float("inf")
+
+        packages.sort()
+
+        for i in range(len(packages)):
+            prefixsum[i + 1] = prefixsum[i] + packages[i]
+
+        for supplier in boxes:
+            wasted = 0
+            i = 0
+            supplier.sort()
+
+            if supplier[-1] < packages[-1]:
+                continue
+
+            for size in supplier:
+                j = bisect.bisect(packages, size, lo=i)
+                wasted += (j - i) * size - prefixsum[j] + prefixsum[i]
+                i = j
+
+            ret = min(ret, wasted)
+
+        return -1 if ret == float("inf") else ret % 1000000007
+```
diff --git a/Problemset/1889-Minimum Space Wasted From Packaging/README_CN.md b/Problemset/1889-Minimum Space Wasted From Packaging/README_CN.md
@@ -0,0 +1,76 @@
+# 1889. 装包裹的最小浪费空间
+给你 `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` 。由于答案可能会 **很大** ，请返回它对 <code>10<sup>9</sup> + 7</code> **取余** 的结果。
+
+#### 示例 1:
+<pre>
+<strong>输入:</strong> packages = [2,3,5], boxes = [[4,8],[2,8]]
+<strong>输出:</strong> 6
+<strong>解释:</strong> 选择第一个供应商最优，用两个尺寸为 4 的箱子和一个尺寸为 8 的箱子。
+总浪费空间为 (4-2) + (4-3) + (8-5) = 6 。
+</pre>
+
+#### 示例 2:
+<pre>
+<strong>输入:</strong> packages = [2,3,5], boxes = [[1,4],[2,3],[3,4]]
+<strong>输出:</strong> -1
+<strong>解释:</strong> 没有箱子能装下尺寸为 5 的包裹。
+</pre>
+
+#### 示例 3:
+<pre>
+<strong>输入:</strong> packages = [3,5,8,10,11,12], boxes = [[12],[11,9],[10,5,14]]
+<strong>输出:</strong> 9
+<strong>解释:</strong> 选择第三个供应商最优，用两个尺寸为 5 的箱子，两个尺寸为 10 的箱子和两个尺寸为 14 的箱子。
+总浪费空间为 (5-3) + (5-5) + (10-8) + (10-10) + (14-11) + (14-12) = 9 。
+</pre>
+
+#### 提示:
+* `n == packages.length`
+* `m == boxes.length`
+* <code>1 <= n <= 10<sup>5</sup></code>
+* <code>1 <= m <= 10<sup>5</sup></code>
+* <code>1 <= packages[i] <= 10<sup>5</sup></code>
+* <code>1 <= boxes[j].length <= 10<sup>5</sup></code>
+* <code>1 <= boxes[j][k] <= 10<sup>5</sup></code>
+* <code>sum(boxes[j].length) <= 10<sup>5</sup></code>
+* `boxes[j]` 中的元素 **互不相同** 。
+
+## 题解 (Python)
+
+### 1. 题解
+```Python
+class Solution:
+    def minWastedSpace(self, packages: List[int], boxes: List[List[int]]) -> int:
+        prefixsum = [0] * (len(packages) + 1)
+        ret = float("inf")
+
+        packages.sort()
+
+        for i in range(len(packages)):
+            prefixsum[i + 1] = prefixsum[i] + packages[i]
+
+        for supplier in boxes:
+            wasted = 0
+            i = 0
+            supplier.sort()
+
+            if supplier[-1] < packages[-1]:
+                continue
+
+            for size in supplier:
+                j = bisect.bisect(packages, size, lo=i)
+                wasted += (j - i) * size - prefixsum[j] + prefixsum[i]
+                i = j
+
+            ret = min(ret, wasted)
+
+        return -1 if ret == float("inf") else ret % 1000000007
+```
diff --git a/Problemset/1889-Minimum Space Wasted From Packaging/Solution.py b/Problemset/1889-Minimum Space Wasted From Packaging/Solution.py
@@ -0,0 +1,26 @@
+class Solution:
+    def minWastedSpace(self, packages: List[int], boxes: List[List[int]]) -> int:
+        prefixsum = [0] * (len(packages) + 1)
+        ret = float("inf")
+
+        packages.sort()
+
+        for i in range(len(packages)):
+            prefixsum[i + 1] = prefixsum[i] + packages[i]
+
+        for supplier in boxes:
+            wasted = 0
+            i = 0
+            supplier.sort()
+
+            if supplier[-1] < packages[-1]:
+                continue
+
+            for size in supplier:
+                j = bisect.bisect(packages, size, lo=i)
+                wasted += (j - i) * size - prefixsum[j] + prefixsum[i]
+                i = j
+
+            ret = min(ret, wasted)
+
+        return -1 if ret == float("inf") else ret % 1000000007
diff --git a/README.md b/README.md
@@ -1232,6 +1232,7 @@
 [1886][1886l]|[Determine Whether Matrix Can Be Obtained By Rotation][1886]                          |![rs]
 [1887][1887l]|[Reduction Operations to Make the Array Elements Equal][1887]                         |![rs]
 [1888][1888l]|[Minimum Number of Flips to Make the Binary String Alternating][1888]                 |![rs]
+[1889][1889l]|[Minimum Space Wasted From Packaging][1889]                                           |![py]
 [1893][1893l]|[Check if All the Integers in a Range Are Covered][1893]                              |![py]
 [1894][1894l]|[Find the Student that Will Replace the Chalk][1894]                                  |![rs]
 [1897][1897l]|[Redistribute Characters to Make All Strings Equal][1897]                             |![rs]
@@ -2908,6 +2909,7 @@
 [1886]:Problemset/1886-Determine%20Whether%20Matrix%20Can%20Be%20Obtained%20By%20Rotation/README.md#1886-determine-whether-matrix-can-be-obtained-by-rotation
 [1887]:Problemset/1887-Reduction%20Operations%20to%20Make%20the%20Array%20Elements%20Equal/README.md#1887-reduction-operations-to-make-the-array-elements-equal
 [1888]:Problemset/1888-Minimum%20Number%20of%20Flips%20to%20Make%20the%20Binary%20String%20Alternating/README.md#1888-minimum-number-of-flips-to-make-the-binary-string-alternating
+[1889]:Problemset/1889-Minimum%20Space%20Wasted%20From%20Packaging/README.md#1889-minimum-space-wasted-from-packaging
 [1893]:Problemset/1893-Check%20if%20All%20the%20Integers%20in%20a%20Range%20Are%20Covered/README.md#1893-check-if-all-the-integers-in-a-range-are-covered
 [1894]:Problemset/1894-Find%20the%20Student%20that%20Will%20Replace%20the%20Chalk/README.md#1894-find-the-student-that-will-replace-the-chalk
 [1897]:Problemset/1897-Redistribute%20Characters%20to%20Make%20All%20Strings%20Equal/README.md#1897-redistribute-characters-to-make-all-strings-equal
@@ -4578,6 +4580,7 @@
 [1886l]:https://leetcode.com/problems/determine-whether-matrix-can-be-obtained-by-rotation/
 [1887l]:https://leetcode.com/problems/reduction-operations-to-make-the-array-elements-equal/
 [1888l]:https://leetcode.com/problems/minimum-number-of-flips-to-make-the-binary-string-alternating/
+[1889l]:https://leetcode.com/problems/minimum-space-wasted-from-packaging/
 [1893l]:https://leetcode.com/problems/check-if-all-the-integers-in-a-range-are-covered/
 [1894l]:https://leetcode.com/problems/find-the-student-that-will-replace-the-chalk/
 [1897l]:https://leetcode.com/problems/redistribute-characters-to-make-all-strings-equal/
diff --git a/README_CN.md b/README_CN.md
@@ -1232,6 +1232,7 @@
 [1886][1886l]|[判断矩阵经轮转后是否一致][1886]                          |![rs]
 [1887][1887l]|[使数组元素相等的减少操作次数][1887]                      |![rs]
 [1888][1888l]|[使二进制字符串字符交替的最少反转次数][1888]              |![rs]
+[1889][1889l]|[装包裹的最小浪费空间][1889]                              |![py]
 [1893][1893l]|[检查是否区域内所有整数都被覆盖][1893]                    |![py]
 [1894][1894l]|[找到需要补充粉笔的学生编号][1894]                        |![rs]
 [1897][1897l]|[重新分配字符使所有字符串都相等][1897]                    |![rs]
@@ -2908,6 +2909,7 @@
 [1886]:Problemset/1886-Determine%20Whether%20Matrix%20Can%20Be%20Obtained%20By%20Rotation/README_CN.md#1886-判断矩阵经轮转后是否一致
 [1887]:Problemset/1887-Reduction%20Operations%20to%20Make%20the%20Array%20Elements%20Equal/README_CN.md#1887-使数组元素相等的减少操作次数
 [1888]:Problemset/1888-Minimum%20Number%20of%20Flips%20to%20Make%20the%20Binary%20String%20Alternating/README_CN.md#1888-使二进制字符串字符交替的最少反转次数
+[1889]:Problemset/1889-Minimum%20Space%20Wasted%20From%20Packaging/README_CN.md#1889-装包裹的最小浪费空间
 [1893]:Problemset/1893-Check%20if%20All%20the%20Integers%20in%20a%20Range%20Are%20Covered/README_CN.md#1893-检查是否区域内所有整数都被覆盖
 [1894]:Problemset/1894-Find%20the%20Student%20that%20Will%20Replace%20the%20Chalk/README_CN.md#1894-找到需要补充粉笔的学生编号
 [1897]:Problemset/1897-Redistribute%20Characters%20to%20Make%20All%20Strings%20Equal/README_CN.md#1897-重新分配字符使所有字符串都相等
@@ -4578,6 +4580,7 @@
 [1886l]:https://leetcode.cn/problems/determine-whether-matrix-can-be-obtained-by-rotation/
 [1887l]:https://leetcode.cn/problems/reduction-operations-to-make-the-array-elements-equal/
 [1888l]:https://leetcode.cn/problems/minimum-number-of-flips-to-make-the-binary-string-alternating/
+[1889l]:https://leetcode.cn/problems/minimum-space-wasted-from-packaging/
 [1893l]:https://leetcode.cn/problems/check-if-all-the-integers-in-a-range-are-covered/
 [1894l]:https://leetcode.cn/problems/find-the-student-that-will-replace-the-chalk/
 [1897l]:https://leetcode.cn/problems/redistribute-characters-to-make-all-strings-equal/
