PHP中寻找最佳单类型数字构成：最小余数与效率优化

本教程旨在解决如何在给定一组可选数字（构成元素）中，为目标数字寻找最匹配的单一构成元素。我们将探讨一种优化策略，通过计算每个可选元素能构成目标数字的次数及其剩余的最小余数，并在此基础上进行排序，从而高效地找到最佳匹配项。

在许多实际应用场景中，我们可能需要从预设的一组数值（例如商品规格、货币面额或资源单位）中，找到一个或多个元素来组合成一个目标数值。一个常见的子问题是：如何找到一个单一的、最有效的构成元素，使得它在尽可能接近目标数值的同时，产生的余数最小。如果存在多个选项产生相同的最小余数，我们可能还需要进一步优化，例如选择使用次数最少的构成元素。

初始尝试与贪婪算法的局限性

假设我们有一个目标金额 $amount，以及一系列可用的构成元素 $sizes。一个直观的思路是采用贪婪算法：总是优先使用当前可用构成元素中最大的一个，并从目标金额中减去相应的部分，直到目标金额无法再被任何构成元素整除。

考虑以下PHP代码示例：

<?php
$amount = 3000;
$sizes = array(1300, 1200, 1100, 1000, 950, 900, 800, 700); // 注意：此处sizes应按降序排列以配合贪婪策略

$result = array();

foreach ($sizes as $size) {
    // 计算当前构成元素能使用的次数
    $times = floor($amount / $size);
    if ($times > 0) {
        $result[$size] = $times;
        // 从剩余金额中减去已使用的部分
        $amount -= $times * $size;
    }
}

echo '<pre>'; print_r($result); echo '</pre>';
?>

对于 $amount = 3000，上述代码的输出将是：

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

Array
(
    [1300] => 2
)

这个结果表明，它使用了两个 1300，总计 2600，剩余 400。然而，这并非最佳的单一构成元素匹配。例如，使用 1000 三次可以完美地构成 3000，余数为 0。贪婪算法的局限在于，它只关注当前步骤的最优解，而忽略了全局最优的可能性。它在处理类似“找零问题”的某些特定场景下有效，但对于寻找“最接近且余数最小的单一构成元素”这类问题则不适用。

优化策略：全面评估与排序

为了克服贪婪算法的局限性，我们需要采取一种更全面的策略：对每一个可用的构成元素进行独立评估，计算它能形成目标金额的次数以及剩余的余数。然后，根据这些评估结果进行排序，找出最佳的匹配项。

即构数智人

即构数智人是由即构科技推出的AI虚拟数字人视频创作平台，支持数字人形象定制、短视频创作、数字人直播等。

36

查看详情

核心思想：

1. 独立评估： 遍历每个 $size，计算它能从原始 $amount 中“取出”多少次（times），以及这样做会留下多少余数（remainder）。
2. 结果存储： 将每个 $size 的 size、times 和 remainder 存储为一个结构化的记录。
3. 优先级排序： 对所有记录进行排序，首先依据 remainder 升序排列（余数越小越好），如果 remainder 相同，则依据 times 升序排列（使用次数越少越好，通常意味着使用了更大的构成元素，效率更高）。

下面是实现这一优化策略的PHP代码：

<?php
$amount = 3000;
$sizes = [ 1300, 1200, 1100, 1000, 950, 900, 800, 700 ]; // 顺序不影响结果，因为是独立评估

$results = []; // 注意变量名改为复数，表示多个结果

foreach ($sizes as $size) {
  // 计算当前构成元素能使用的次数
  $times = (int)floor($amount / $size);
  // 计算剩余余数
  $remainder = $amount - $times * $size;

  // 将结果存储为关联数组
  $results[] = [
      'size' => $size,
      'times' => $times,
      'remainder' => $remainder
  ];
}

// 使用 usort 函数进行自定义排序
usort($results, static function ($item1, $item2): int {
  // 首先比较余数：余数小的排在前面
  $comparison = $item1['remainder'] <=> $item2['remainder'];

  // 如果余数相同，则比较使用次数：使用次数少的排在前面
  return $comparison === 0 ? $item1['times'] <=> $item2['times'] : $comparison;
});

echo '<pre>'; print_r($results); echo '</pre>';
?>

代码解析与输出分析

1. 数据初始化： $amount 是目标数字，$sizes 是可用的构成元素数组。
2. 遍历与计算： foreach 循环遍历 $sizes 数组中的每一个 $size。
   • $times = (int)floor($amount / $size);：计算当前 $size 能被 $amount 整除的次数。floor() 确保结果是整数，(int) 进行类型转换。
   • $remainder = $amount - $times * $size;：计算在使用了 $times 次 $size 后，剩余的余数。
   • $results[] = [...]：将计算出的 size、times 和 remainder 作为一个关联数组添加到 $results 数组中。
3. 自定义排序 (usort)：
   • usort() 函数使用用户提供的比较函数对数组进行排序。
   • 匿名函数 static function ($item1, $item2): int 接收两个待比较的元素。
   • $comparison = $item1['remainder'] zuojiankuohaophpcn=> $item2['remainder'];：使用PHP 7引入的飞船操作符 (<=>) 比较两个元素的 remainder。如果 $item1['remainder'] 小于 $item2['remainder']，$comparison 为 -1；如果相等，为 0；如果大于，为 1。
   • return $comparison === 0 ? $item1['times'] <=> $item2['times'] : $comparison;：这是一个三元运算符。如果 remainder 相同 ($comparison === 0)，则进一步比较 times；否则，直接返回 remainder 的比较结果。这样就实现了先按 remainder 升序，再按 times 升序的排序逻辑。

上述代码的输出如下：

Array
(
    [0] => Array
        (
            [size] => 1000
            [times] => 3
            [remainder] => 0   // 最佳结果：余数为0
        )

    [1] => Array
        (
            [size] => 950
            [times] => 3
            [remainder] => 150 // 次佳结果
        )

    [2] => Array
        (
            [size] => 700
            [times] => 4
            [remainder] => 200
        )

    [3] => Array
        (
            [size] => 900
            [times] => 3
            [remainder] => 300
        )

    [4] => Array
        (
            [size] => 1300
            [times] => 2
            [remainder] => 400
        )

    [5] => Array
        (
            [size] => 1200
            [times] => 2         // 余数与下一个相同
            [remainder] => 600
        )

    [6] => Array
        (
            [size] => 800
            [times] => 3         // 余数与上一个相同，但使用次数更多，所以排在后面
            [remainder] => 600
        )

    [7] => Array
        (
            [size] => 1100
            [times] => 2
            [remainder] => 800
        )
)

从输出可以看出，排序后的数组第一个元素就是最佳匹配：使用 1000 三次，余数为 0。这正是我们期望的优化结果。当余数相同时（例如 1200 * 2 和 800 * 3 都产生 600 的余数），usort 会根据 times 进行二次排序，优先选择使用次数更少 (1200 * 2) 的方案。

重要注意事项与应用场景

1. 问题范围界定： 此教程和提供的解决方案专注于寻找最佳单一类型的构成元素。它回答的是“哪个单一的构成元素，在重复使用时，能最接近目标数字并留下最小余数？”的问题。
2. 与“找零问题”的区别： 原始问题描述中提到了 3500 可以由 1200, 1200, 1100 组成，这暗示了一个更复杂的“找零问题”或“背包问题”变体，即寻找多种不同构成元素的组合。本解决方案并未解决此类组合问题，而是提供了一个更基础但同样重要的优化方法。
3. 适用场景：
   • 快速评估效率： 当你需要快速了解每个可用单位（如产品规格、运输箱尺寸）单独使用时，能多大程度上满足总需求。
   • 优先级决策： 在资源有限或需要选择单一标准件时，帮助决策者选择最“合算”的构成元素。
   • 数据分析： 作为更复杂组合算法的前置步骤，用于筛选或优化构成元素列表。
4. 组合问题： 如果实际需求是寻找多种不同构成元素的组合来精确或近似目标数字（如 3500 = 1200 + 1200 + 1100），则需要采用更高级的算法，如动态规划（Dynamic Programming）或回溯（Backtracking）算法。

总结

通过对每个构成元素进行独立评估并结合自定义排序，我们能够有效地在PHP中找到最适合目标数字的单一类型构成元素，优先考虑最小余数，并在余数相同时进一步考虑使用效率。这种方法比简单的贪婪算法更健壮，能确保找到特定条件下的最优解，为需要快速评估单个构成元素效率的场景提供了清晰且实用的解决方案。

以上就是PHP中寻找最佳单类型数字构成：最小余数与效率优化的详细内容，更多请关注php中文网其它相关文章！