2024-08-31：用 go 语言，给定一个数组 apple，包含 n 个元素，每个元素表示一个包裹中的苹果数量；另一个数组 capacity 包含 m 个元素，表示 m 个不同箱子的容量。有 n 个包裹，每个包裹内装有

作者：福大大架构师每日一题

2024-08-31
北京
本文字数：1167 字
阅读完需：约 4 分钟

2024-08-31：用 go 语言，给定一个数组 apple，包含 n 个元素，每个元素表示一个包裹中的苹果数量；

另一个数组 capacity 包含 m 个元素，表示 m 个不同箱子的容量。

有 n 个包裹，每个包裹内装有指定数量的苹果，以及 m 个箱子，每个箱子的容量不同。

任务是将这 n 个包裹中的所有苹果重新分配到箱子中，最小化所需的箱子数量。

需要注意的是，可以将同一个包裹中的苹果分装到不同的箱子中。

需要计算并返回实现这一目标所需的最小箱子数量。

输入：apple = [1,3,2], capacity = [4,3,1,5,2]。

输出：2。

解释：使用容量为 4 和 5 的箱子。

总容量大于或等于苹果的总数，所以可以完成重新分装。

答案 2024-08-31：

chatgpt

题目来自 leetcode3074。

大体步骤如下：

1.首先，计算所有苹果的总数，用变量 s 表示。

2.将箱子的容量按照降序排列，通过调用 slices 包里的 SortFunc 函数，将 capacity 数组按照从大到小排序。

3.遍历排序后的容量数组，从大到小依次尝试将苹果放入箱子中。

4.在每个循环中，尝试将当前箱子的容量 c 与苹果总数 s 比较：

如果 s 小于等于 0，表示所有苹果都已经装箱了，返回当前箱子的索引 + 1，即已经使用的箱子数目。
如果 s 大于 0，继续尝试将苹果放入下一个箱子，更新 s 为剩余苹果的数量。

5.如果循环结束时仍未返回箱子数量，说明无法将所有苹果重新分装到箱子中，返回 -1。

总的时间复杂度：

计算苹果总数的时间复杂度为 O(n)，n 为苹果数量。
对箱子容量进行排序的时间复杂度为 O(m log m)，m 为箱子数量。
遍历箱子容量的时间复杂度为 O(m)，m 为箱子数量。

综合起来，总的时间复杂度大致在 O((n + m) log m) 的数量级。

总的额外空间复杂度：

只使用了常数级别的额外空间，因此额外空间复杂度为 O(1)。

Go 完整代码如下：

package main
import (  "fmt"  "slices")
func minimumBoxes(apple, capacity []int) int {  s := 0  for _, x := range apple {    s += x  }  slices.SortFunc(capacity, func(a, b int) int { return b - a })  for i, c := range capacity {    s -= c    if s <= 0 { // 所有苹果都装入了箱子      return i + 1 // 0 到 i 有 i+1 个箱子    }  }  return -1}
func main() {
  apple := []int{1, 3, 2}  capacity := []int{4, 3, 1, 5, 2}  fmt.Println(minimumBoxes(apple, capacity))}

复制代码

Rust 完整代码如下：

fn minimum_boxes(apple: Vec<i32>, mut capacity: Vec<i32>) -> i32 {    let mut s: i32 = apple.iter().sum();    capacity.sort_by(|a, b| b.cmp(a));    for (i, &c) in capacity.iter().enumerate() {        s -= c;        if s <= 0 {            return (i + 1) as i32;        }    }    -1}
fn main() {    let apple = vec![1, 3, 2];    let capacity = vec![4, 3, 1, 5, 2];    println!("{}", minimum_boxes(apple, capacity));}