PHP：从加起来给定数量的数字列表中找到两个或多个数字

Question

我正在尝试创建一个可以让我的生活更轻松的小 php 脚本。 基本上，我将在一个页面上有 21 个文本字段，我将在其中输入 20 个不同的数字。在最后一个字段中，我将输入一个数字，我们称之为 TOTAL AMOUNT。我想要脚本做的只是指出 20 个字段中的哪些数字加起来会达到 TOTAL AMOUNT。

例子：

field1 = 25.23
field2 = 34.45
field3 = 56.67
field4 = 63.54
field5 = 87.54
....
field20 = 4.2

Total Amount = 81.90

输出：field1 + fields3 = 81.90

有些字段的值可能为 0，因为有时我只需要输入 5-15 个字段，最大值为 20。

如果有人能帮助我解决这个问题的 php 代码，将不胜感激。

Answer 1

如果你看一下oezis algorithm，一个缺点就很明显了：它会花费大量时间来汇总已知无效的数字。 （例如，如果 1 + 2 已经太大，那么尝试 1 + 2 + 3、1 + 2 + 3 + 4、1 + 2 + 3 + 4 + 5、... 也没有任何意义.)

因此我写了一个改进的版本。它不使用一点魔法，它使一切都是手动的。一个缺点是，它需要对输入值进行排序（使用rsort）。但这应该不是什么大问题;)

function array_sum_parts($vals, $sum){
    $solutions = array();
    $pos = array(0 => count($vals) - 1);
    $lastPosIndex = 0;
    $currentPos = $pos[0];
    $currentSum = 0;
    while (true) {
        $currentSum += $vals[$currentPos];

        if ($currentSum < $sum && $currentPos != 0) {
            $pos[++$lastPosIndex] = --$currentPos;
        } else {
            if ($currentSum == $sum) {
                $solutions[] = array_slice($pos, 0, $lastPosIndex + 1);
            }

            if ($lastPosIndex == 0) {
                break;
            }

            $currentSum -= $vals[$currentPos] + $vals[1 + $currentPos = --$pos[--$lastPosIndex]];
        }
    }

    return $solutions;
}

oezis 测试程序的修改版本（见末尾）输出：

possibilities: 540
took: 3.0897309780121

所以执行只需要 3.1 秒，而 oezis 代码在我的机器上执行 65 秒（是的，我的机器很慢）。这比 快 20 倍！

此外，您可能会注意到，我的代码找到了540 而不是338 的可能性。这是因为我调整了测试程序以使用整数而不是浮点数。 直接浮点比较很少是正确的做法，这是一个很好的例子：您有时会得到59.959999999999 而不是59.96，因此不会计算匹配。所以，如果我用整数运行 oezis 代码，它也会找到 540 种可能性；）

测试程序：

// Inputs
$n = array();
$n[0]  = 6.56;
$n[1]  = 8.99;
$n[2]  = 1.45;
$n[3]  = 4.83;
$n[4]  = 8.16;
$n[5]  = 2.53;
$n[6]  = 0.28;
$n[7]  = 9.37;
$n[8]  = 0.34;
$n[9]  = 5.82;
$n[10] = 8.24;
$n[11] = 4.35;
$n[12] = 9.67;
$n[13] = 1.69;
$n[14] = 5.64;
$n[15] = 0.27;
$n[16] = 2.73;
$n[17] = 1.63;
$n[18] = 4.07;
$n[19] = 9.04;
$n[20] = 6.32;

// Convert to Integers
foreach ($n as &$num) {
    $num *= 100;
}
$sum = 57.96 * 100;

// Sort from High to Low
rsort($n);

// Measure time
$start = microtime(true);
echo 'possibilities: ', count($result = array_sum_parts($n, $sum)), '<br />';
echo 'took: ', microtime(true) - $start;

// Check that the result is correct
foreach ($result as $element) {
    $s = 0;
    foreach ($element as $i) {
        $s += $n[$i];
    }
    if ($s != $sum) echo '<br />FAIL!';
}

var_dump($result);

Answer 2

很抱歉添加了一个新答案，但这是一个全新的解决方案，可以解决生命、宇宙和一切的所有问题……：

function array_sum_parts($n,$t,$all=false){
    $count_n = count($n); // how much fields are in that array?
    $count = pow(2,$count_n); // we need to do 2^fields calculations to test all possibilities

    # now i want to look at every number from 1 to $count, where the number is representing
    # the array and add up all array-elements which are at positions where my actual number
    # has a 1-bit
    # EXAMPLE:
    # $i = 1  in binary mode 1 = 01  i'll use ony the first array-element
    # $i = 10  in binary mode 10 = 1010  ill use the secont and the fourth array-element
    # and so on... the number of 1-bits is the amount of numbers used in that try

    for($i=1;$i<=$count;$i++){ // start calculating all possibilities
        $total=0; // sum of this try
        $anzahl=0; // counter for 1-bits in this try
        $k = $i; // store $i to another variable which can be changed during the loop
        for($j=0;$j<$count_n;$j++){ // loop trough array-elemnts
            $total+=($k%2)*$n[$j]; // add up if the corresponding bit of $i is 1
            $anzahl+=($k%2); // add up the number of 1-bits
            $k=$k>>1; //bit-shift to the left for looking at the next bit in the next loop
        }
        if($total==$t){
            $loesung[$i] = $anzahl; // if sum of this try is the sum we are looking for, save this to an array (whith the number of 1-bits for sorting)
            if(!$all){
                break; // if we're not looking for all solutions, make a break because the first one was found
            }
        }
    }

    asort($loesung); // sort all solutions by the amount of numbers used


    // formating the solutions to getting back the original array-keys (which shoud be the return-value)
    foreach($loesung as $val=>$anzahl){
        $bit = strrev(decbin($val));
        $total=0;
        $ret_this = array();
        for($j=0;$j<=strlen($bit);$j++){
            if($bit[$j]=='1'){
                $ret_this[] = $j;
            }   
        }
        $ret[]=$ret_this;
    }

    return $ret;
}

// Inputs
$n[0]=6.56;
$n[1]=8.99;
$n[2]=1.45;
$n[3]=4.83;
$n[4]=8.16;
$n[5]=2.53;
$n[6]=0.28;
$n[7]=9.37;
$n[8]=0.34;
$n[9]=5.82;
$n[10]=8.24;
$n[11]=4.35;
$n[12]=9.67;
$n[13]=1.69;
$n[14]=5.64;
$n[15]=0.27;
$n[16]=2.73;
$n[17]=1.63;
$n[18]=4.07;
$n[19]=9.04;
$n[20]=6.32;

// Output
$t=57.96;

var_dump(array_sum_parts($n,$t)); //returns one possible solution (fuc*** fast)

var_dump(array_sum_parts($n,$t,true)); // returns all possible solution (relatively fast when you think of all the needet calculations)

如果您不使用第三个参数，它将返回最佳（使用最少的数字）解决方案作为数组（输入数组的键） - 如果您将第三个参数设置为 true, ALL返回解决方案（为了测试，我在他的帖子中使用了与 zaf 相同的数字 - 在这种情况下有 338 个解决方案，在我的机器上大约 10 秒内找到）。

编辑： 如果你得到了所有，你会得到“最好”的排序结果 - 没有这个，你只会得到第一个找到的解决方案（不一定是最好的）。

编辑2： 为了满足一些解释的愿望，我评论了代码的基本部分。如果有人需要更多解释，请询问

Answer 3

1. Check and eliminate fields values more than 21st field

2. Check highest of the remaining, Add smallest, 

3. if its greater than 21st eliminate highest (iterate this process)

   4. If lower: Highest + second Lowest, if equal show result.

   5. if higher go to step 7

   6. if lower go to step 4

7. if its lower than add second lowest, go to step 3.

8. if its equal show result

这是高效的，并且会花费更少的执行时间。

Answer 4

以下方法会给你一个答案......几乎所有的时间。根据您的喜好增加迭代变量。

<?php

// Inputs
$n[1]=8.99;
$n[2]=1.45;
$n[3]=4.83;
$n[4]=8.16;
$n[5]=2.53;
$n[6]=0.28;
$n[7]=9.37;
$n[8]=0.34;
$n[9]=5.82;
$n[10]=8.24;
$n[11]=4.35;
$n[12]=9.67;
$n[13]=1.69;
$n[14]=5.64;
$n[15]=0.27;
$n[16]=2.73;
$n[17]=1.63;
$n[18]=4.07;
$n[19]=9.04;
$n[20]=6.32;

// Output
$t=57.96;

// Let's try to do this a million times randomly
// Relax, thats less than a blink
$iterations=1000000;
while($iterations-->0){
    $z=array_rand($n, mt_rand(2,20));
    $total=0;
    foreach($z as $x) $total+=$n[$x];
    if($total==$t)break;
}

// If we did less than a million times we have an answer
if($iterations>0){
    $total=0;
    foreach($z as $x){
        $total+=$n[$x];
        print("[$x] + ". $n[$x] . " = $total<br/>");
    }
}

?>

一种解决方案：

[1] + 8.99 = 8.99
[4] + 8.16 = 17.15
[5] + 2.53 = 19.68
[6] + 0.28 = 19.96
[8] + 0.34 = 20.3
[10] + 8.24 = 28.54
[11] + 4.35 = 32.89
[13] + 1.69 = 34.58
[14] + 5.64 = 40.22
[15] + 0.27 = 40.49
[16] + 2.73 = 43.22
[17] + 1.63 = 44.85
[18] + 4.07 = 48.92
[19] + 9.04 = 57.96

Answer 5

一个可能效率低下但简单的回溯解决方案

function subset_sums($a, $val, $i = 0) {
    $r = array();
    while($i < count($a)) {
        $v = $a[$i];
        if($v == $val)
            $r[] = $v;
        if($v < $val)
            foreach(subset_sums($a, $val - $v, $i + 1) as $s)
                $r[] = "$v $s";
        $i++;
    }
    return $r;
}

例子

$ns = array(1, 2, 6, 7, 11, 5, 8, 9, 3);
print_r(subset_sums($ns, 11));

结果

Array
(
    [0] => 1 2 5 3
    [1] => 1 2 8
    [2] => 1 7 3
    [3] => 2 6 3
    [4] => 2 9
    [5] => 6 5
    [6] => 11
    [7] => 8 3
)

Answer 6

我认为答案并不像尼克所说的那么简单。假设您有以下数字：

1 2 3 6 8

寻找金额10

niks 解决方案会这样做（如果我理解正确的话）：

1*8 = 9 = too low
adding next lowest (2) = 11 = too high

现在他会删除高数并重新开始取新的最高数

1*6 = 7 = too low
adding next lowest (2) = 9 = too low
adding next lowest (3) = 12 = too high

... 等等，完美的答案就是 成为8+2 = 10...我认为唯一的解决方案是尝试所有可能的组合 如果找到您正在寻找的数量并停止（或真正计算所有，如果有不同的解决方案并保存哪个使用最少的数字）。

编辑：真正计算 21 个数字的所有可能组合最终会得到非常、非常、非常多的计算 - 所以必须有任何“智能”解决方案来按特殊顺序添加数字（就像 niks 帖子中的那个 - 与一些改进，也许这会给我们带来一个可靠的解决方案）

Answer 7

在不知道这是否是家庭作业的情况下，我可以给你一些伪代码作为可能的解决方案的提示，注意解决方案不是很有效，更多的是演示。

提示：

将每个字段值与所有字段值进行比较，并在每次迭代时检查它们的总和是否等于TOTAL_AMOUNT。

伪代码：

for i through field  1-20
 for j through field 1-20
   if value of i + value of j == total_amount
        return i and j

更新：

您似乎拥有的是Subset sum problem，在 Wiki 链接中给出的是该算法的伪代码，它可能有助于为您指明正确的方向。