Question

我有一个数字列表，按降序排序，数组大小是可变的，任何数字都可以出现（通常小于1000）

给定一个输入数字（x），我需要找到列表中值的最佳组合，即大于x的可能最小值。我一直在阅读NP优化和总和子类型问题，但还没有找到解决方案。我已经找到了一些近似算法的伪代码，但我想从给定的数字列表中找到确切的最优解。感谢

Answer 1

从你的评论我明白输入数组有无符号（整数）。

这个问题与subset sum problem with non-negative integers似乎没有什么不同，Partial Cell Match可以在多项式时间内解决。

我发现这是一个性能相当好的算法，可以找到最佳解决方案：

伪代码

中的算法

For each element of the array:
    select this element  
    if sum of selected <= x:
        # Sum is too small, so add more (smaller) term(s)
        execute algorithm recursively for the remaining part of array
    else if < sum in best solution so far:
        # Sum is closer to target, so this is currently the best
        best solution = current selected terms
    # Back-track: remove this term from the sum
    unselect this element
return best solutiuon

当递归调用算法时，先前选择的术语保持选中，并且在循环中再选择一个术语。它可以再次递归等等。所选术语的总数对应于递归的深度。

递归有两种方式可以减少许多组合：

当选择高值术语时，超过目标值的剩余值变得相对较小，从而减少了其他术语可能有助于（更好）解决方案的可能性;
当选择较低值的术语时，剩余的术语数量相对较少（因为顺序），因此也减少了可能性。

这表明时间复杂度小于 O（2 ⁿ），这将是必须调查所有可能组合时的复杂性（或常数）它的一部分）。

实施

这是JavaScript中的一个实现，因此您可以运行它。它提供了一个随机化按钮，因此您可以使用随机数和随机目标值生成任意给定长度的数组。

算法似乎以 O（n.logn）的时间顺序运行，只需查看它平均检查的组合数。这当然不是证明。

代码中的注释应该给出澄清。

// Main  algorithm
function solve(a /* array of int */, x /* int */) {
    // Initialise
    var best = {sum: a[0] * a.length, numSumsVerified: 0, numTerms: 0, terms: []};
    var current = {sum: 0, terms: []};

    function recurse(start) {
        var ok = start < a.length;
        for (var i = start; i < a.length && best.sum > x + 1 && ok; i++) {
            // Use this term for the sum
            current.sum += current.terms[current.terms.length] = a[i];
            // Keep statistics of how many combinations we check
            best.numSumsVerified++;
            if (current.sum <= x) {
                // Sum is too small, so add more (smaller) term(s)
                ok = recurse(i+1);
            } else if (current.sum < best.sum) {
                // Sum is closer to target, so this is currently the best
                best.sum = current.sum;
                best.terms = current.terms.slice(0);
            }
            // Back-track: remove this term from the sum
            current.sum -= current.terms.pop();
        }
        return ok || i > start + 1;
    }

    // start the search, and capture errors
    try {
        recurse(0);
    } catch (ex) {
        best.error = 'Too much recursion!';
        best.sum = null;
        return best;
    }
    best.numTerms = best.terms.length;
    // if no solution, set error message
    if (!best.terms.length) {
        best.error = 'no solution';
        best.sum = null;
    }
    return best;
}

// Utility for randomizing
function createRandomNumbers(limit, count) {
    res = [];
    while (count--) res.push(Math.floor(Math.random() * limit));
    return res;
}

// I/O

var inputA = document.querySelector('#a');
var inputX = document.querySelector('#x');
var buttonSolve = document.querySelector('#solve');
var inputSize = document.querySelector('#size');
var buttonRandom = document.querySelector('#randomize');
var output = document.querySelector('pre');

buttonSolve.onclick = function() {
    // Get input
    var a = inputA.value.match(/\d+/g).map(Number);
    var x = Number(inputX.value);
    // Sort descending
    a.sort(function(a,b) { return b-a; });
    // Solve
    var result = solve(a, x);
    // Output
    inputA.value = a.join(' '); // just for reformatting
        // Reduce detail when many items
    if (result.terms.length > 100) result.terms = '(too many to display)';
    output.textContent = JSON.stringify(result, null, 4);
};

buttonRandom.onclick = function() {
    // Generate random input
    var size = Number(inputSize.value);
    var limit = size * 20;
    var a = createRandomNumbers(limit, size).sort((a,b) => b-a);
    var sum = a.reduce((a,b) => a+b);
    var x = createRandomNumbers(sum, 1).pop();
    // Populate the input boxes
    inputA.value = a.join(' ');
    inputX.value = x;
    // Trigger click on "solve" button
    setTimeout(buttonSolve.click.bind(buttonSolve), 0);
}

Enter list of integers: <input id="a" size="50" value="18 13 12 10 9 8 6 6 1 0"><br>
Sum must be larger than: <input id="x" size="10" value="16"><br>
<button id="solve">Solve</button><br>
Desired array size: <input id="size" size="6" value="50">
<button id="randomize">Random Input</button>
<pre></pre>

由于此算法对添加到组合中的每个术语执行递归调用，因此递归可能会深入到大型输入数组。在某一点上，它可能达到堆栈限制。在我的浏览器中，限制经常接近10,000个元素的数组大小。如果需要将这种算法用于这种大型数组，则可以在不使用递归的情况下重写该算法。

Answer 2

这听起来非常像knapsack problem。如果是，那么找到一个精确的解决方案并不容易。

为什么？这是因为最佳解决方案可能包含您的数字的任何子集。有2 ^ N个子集，因此搜索解决方案的空间非常大。

它有多大？

Items | Search Space          | How this feels
16    | 65,536                | I can do it!
32    | 4,294,967,296         | Better go get lunch
40    | 1,099,511,627,776     | If I only had a supercomputer
50    | 1,125,899,906,842,624 | I will watch as the last stars day

有一些技巧和事情可以减少搜索空间，但是对于低项目数量，你仍然会遇到非常大的问题。

鉴于此，你应该：

仅选择较小的问题规模并使用详尽的搜索，因为它易于实施。
了解分支定界和其他搜索空间缩减技术
近似。每个人都这样做。

找到＆gt;中的数字列表中的元素的最佳总和。一个给定的数字

2 个答案:

伪代码

实施