Java教程：优化图书打包算法，解决整数除法陷阱

问题描述

在chef的搬家过程中，他需要打包大量的书籍。具体情况如下：

• Chef拥有 X 个书架。
• 每个书架上恰好有 Y 本书。
• 每个纸箱最多可以容纳 Z 本书。
• 一个关键约束是：来自不同书架的书籍不能放置在同一个箱子中。

我们的目标是计算打包所有书籍所需的最小纸箱总数。

输入格式: 第一行包含一个整数 T，表示测试用例的数量。 每个测试用例包含一行，包含三个空格分隔的整数 X, Y, Z。

输出格式: 对于每个测试用例，输出一行一个整数，表示所需的最小纸箱总数。

示例:

问题分析与常见错误

解决此类问题的第一步是理解核心约束。题目明确指出“书籍从不同书架不能放在同一个箱子中”。这意味着我们必须首先计算每个书架所需的箱子数量，然后将这个数量乘以书架的总数 X，才能得到最终答案。

每个书架所需的箱子数： 如果一个书架有 Y 本书，每个箱子最多能装 Z 本，那么所需的箱子数就是 Y / Z 的向上取整。例如：

• 如果 Y=9, Z=9，需要 9/9 = 1 个箱子。
• 如果 Y=9, Z=7，需要 9/7 = 1 余 2，这意味着1个箱子装7本，还剩2本需要另一个箱子，所以总共需要 1 + 1 = 2 个箱子。
• 如果 Y=3, Z=2，需要 3/2 = 1 余 1，同理需要 1 + 1 = 2 个箱子。

常见的错误逻辑： 许多初学者在处理向上取整时容易犯错。一个常见的错误是直接使用 Y / Z （整数除法）然后简单地加 1，例如：

int r = Y / Z; // 整数除法，向下取整
int q = r + 1; // 总是加1

这种方法的问题在于，当 Y 恰好是 Z 的倍数时，它会多计算一个箱子。 例如，当 Y=9, Z=9 时：

• r = 9 / 9 = 1
• q = 1 + 1 = 2 这导致一个书架需要2个箱子，与实际的1个箱子不符。

此外，一些代码可能会包含针对特殊情况的冗余判断，例如 if (Y <= Z) 或 if (X == 0 && Y == 0 && Z == 0)。虽然这些判断在特定条件下能得到正确结果，但一个健壮且高效的解决方案应该能够通过统一的逻辑处理所有合法输入情况，从而简化代码并减少出错的可能性。

立即学习“Java免费学习笔记（深入）”；

正确的解决方案：向上取整

解决这个问题的关键在于正确实现整数的向上取整（Ceiling Division）。在Java（以及大多数支持整数除法的编程语言）中，A / B 默认执行的是向下取整。为了实现向上取整，我们可以利用模运算符 %。

向上取整的通用方法（纯整数运算）：

1. 首先计算 Y / Z 的整数部分，这会得到向下取整的结果。
2. 然后检查 Y % Z 是否大于 0。如果余数大于 0，说明 Y 不能被 Z 整除，还需要额外一个箱子来装剩余的书籍。

具体步骤： 对于每个书架：

1. 计算 nbBoxesPerShelf = Y / Z;
2. 如果 Y % Z > 0，则 nbBoxesPerShelf++;

最后，总的箱子数就是 nbBoxesPerShelf * X。

法语写作助手

法语助手旗下的AI智能写作平台，支持语法、拼写自动纠错，一键改写、润色你的法语作文。

31

查看详情

示例代码（Java）

以下是采用正确向上取整逻辑的Java实现代码：

import java.util.Scanner;

public class BookPacking {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int T = sc.nextInt(); // 读取测试用例数量

        // 循环处理每个测试用例
        // 题目通常会限制T的范围，例如1 <= T <= 100
        while (T-- > 0) { 
            int nbShelves = sc.nextInt();       // X: 书架数量
            int nbBooksPerShelf = sc.nextInt(); // Y: 每个书架的书籍数量
            int nbBooksPerBox = sc.nextInt();   // Z: 每个箱子容量

            // 计算每个书架所需的箱子数量
            int nbBoxesPerShelf = nbBooksPerShelf / nbBooksPerBox;

            // 如果有余数，说明还需要一个额外的箱子
            if (nbBooksPerShelf % nbBooksPerBox > 0) {
                nbBoxesPerShelf++;
            }

            // 计算总箱子数量并输出
            System.out.println(nbBoxesPerShelf * nbShelves);
        }
        sc.close(); // 关闭Scanner
    }
}

示例代码执行与解释

让我们使用提供的示例来验证上述代码的逻辑：

1. 输入: 5 9 9

   • nbShelves = 5, nbBooksPerShelf = 9, nbBooksPerBox = 9
   • nbBoxesPerShelf = 9 / 9 = 1
   • 9 % 9 = 0 (无余数)，所以 nbBoxesPerShelf 保持 1。
   • 总箱数: 1 * 5 = 5。 正确。

2. 输入: 5 9 7

   • nbShelves = 5, nbBooksPerShelf = 9, nbBooksPerBox = 7
   • nbBoxesPerShelf = 9 / 7 = 1
   • 9 % 7 = 2 (有余数)，所以 nbBoxesPerShelf 变为 1 + 1 = 2。
   • 总箱数: 2 * 5 = 10。 正确。

3. 输入: 2 3 2

   • nbShelves = 2, nbBooksPerShelf = 3, nbBooksPerBox = 2
   • nbBoxesPerShelf = 3 / 2 = 1
   • 3 % 2 = 1 (有余数)，所以 nbBoxesPerShelf 变为 1 + 1 = 2。
   • 总箱数: 2 * 2 = 4。 正确。

4. 输入: 22 34 12

   • nbShelves = 22, nbBooksPerShelf = 34, nbBooksPerBox = 12
   • nbBoxesPerShelf = 34 / 12 = 2
   • 34 % 12 = 10 (有余数)，所以 nbBoxesPerShelf 变为 2 + 1 = 3。
   • 总箱数: 3 * 22 = 66。 正确。

注意事项与总结

• 理解问题核心：在解决问题之前，务必仔细阅读并理解所有约束条件，特别是“不同书架的书不能放在同一个箱子中”这类关键信息。
• 整数除法的陷阱：在需要向上取整的场景中，直接的整数除法 A / B 总是向下取整。务必使用 (A / B) + (A % B > 0 ? 1 : 0) 或 (A + B - 1) / B（后者适用于 A > 0, B > 0 的情况）等方式实现向上取整。
• 代码简洁性：尽量避免为特定边缘情况编写独立的 if-else 分支，而是寻求一个能够统一处理所有合法输入的通用逻辑。这使得代码更简洁、更易于维护，并减少了引入新错误的风险。
• 资源管理：在Java中，使用 Scanner 读取输入后，在程序结束时调用 sc.close() 是一个良好的实践，以释放系统资源。

通过本教程，您应该已经掌握了如何正确处理涉及资源分配和向上取整的编程问题，并能够避免常见的整数除法陷阱。

以上就是Java教程：优化图书打包算法，解决整数除法陷阱的详细内容，更多请关注php中文网其它相关文章！