Algorithm 具有长度的值子集>=N和sum>=s

给出一系列值（例如10、15、20、30、70）、值N（例如3）和S（例如100），找出满足以下条件的子集：

子集的长度>=N

子集之和>=S

子集的和也应该是最小可能的（剩余值的和应该是最大可能的）（例如，结果子集应该是（10,20,70），而不是（15,20,70），也满足1.和2.）

我正在研究一些问题和解决方案（背包问题、箱子包装问题等），但没有发现它们适用。由于某些原因，互联网上的类似问题也不适用（例如，子集中的元素数量是固定的）

有人能给我指出正确的方向吗？除了用尽所有可能的组合，还有其他解决方案吗

我用ruby代码实现的编辑工作算法，我想可以进一步优化：

def find_subset_with_sum_and_length_threshold(vals, min_nr, min_sum)
    sum_map = {}
    vals.sort.each do |v|
      sum_map.keys.sort.each do |k|
        addends = sum_map[k] + [v]
        if (addends.length >= min_nr && k+v >= min_sum)
          return addends
        else
          sum_map[k+v] = addends
        end
      end
      sum_map[v] = [v] if sum_map[v].nil?
    end
  end

---

这与0-1背包问题没有太大区别

Zero-initialize a matrix with S+U rows and N columns(U is the largest list value)
Zero-initialize a bit array A with S+U elements
For each value (v) in the list:
  For each j<S:
    If M[N-1,j] != 0 and M[N-1, j + v] == 0:
      M[N-1, j + v] = v
      A[j + v] = true
  For i=N-2 .. 0:
    For each j<S:
      If M[i,j] != 0 and M[i+1, j + v] == 0:
        M[i+1, j + v] = v
  M[0,v] = v
Find first nonzero element in M[N-1,S..S+U]
Reconstruct other elements of the subset by subtracting found value from its\
  index and using the result as index in preceding column of the matrix\
  (or in the last column, depending on the corresponding bit in 'A').

Zero使用S+U行和N列初始化矩阵（U是最大的列表值）
零使用S+U元素初始化位数组a
对于列表中的每个值（v）：
对于每个j，这是一个微小的变化。请参阅部分
伪多项式时间动态规划解决方案
。除了跟踪给定集合中的特定和是否可能（即存储真/假），您还需要存储长度以满足：

子集的长度>=N
如果
sum of subset=S
，则与上述问题完全相似。对于
sum of subset>=S
条件，我想您可以在构建Wiki页面中提到的数组时测试此条件。
如果我是正确的，第一个解决方案基本上是构建所有子集的和矩阵，长度解是（70,30,20,10）？我将研究第二个解决方案。关于第二个解决方案，我关心的是可能的冲突（例如，首先A[j+v]设置为3，然后另一个v可能将A[j+v]再次设置为另一个值，例如2。如果A[j+v]是[S..S+U]中的第一个元素最后，我们找不到第一个解决方案，因为它后来被写入了values循环）。但我知道你的解决方案的目的是什么——构建矩阵和和和数组，然后找出哪种组合产生的和最接近S。我的想法类似。@MatkoMedenjak：（第一个解决方案）如果解决方案子集需要的元素多于N，则N之后的所有剩余元素都会在最后一列中累积（第0列->第10列，第1列->第20列，第2列->第30列和第70列）。这是答案初始版本中的一个错误。现在它已修复。@MatkoMedenjak：（第二种解决方案）将[j+v]设置为某个值（3）后，它可能只会被较大的值（4+）覆盖。这可能会用另一个仍然遵守所有约束的解决方案覆盖第一个解决方案。与第一个算法不同，此算法不是第一个找到的子集，而是生成最大的子集。@MatkoMedenjak:顺便说一句，OP中存在矛盾。问题名称要求最小化子集大小，而问题正文不需要。我的两种算法都不会最小化此大小。但如果需要，请使用第一种算法和布尔矩阵，而不是最后一列使用整数数组（包含当前子集大小），该数组应仅被较小的值覆盖。要重建生成的子集，请像第二种算法一样使用值/父矩阵。
Zero-initialize an integer array A with S+U elements
i=0
For each value (v) in the list:
  For each j<S:
    If A[j] != 0 and A[j + v] < A[j] + 1:
      A[j + v] = A[j] + 1
      V[i,j + v] = v
      P[i,j + v] = I[j]
      I[j + v] = i
  If A[v] == 0:
    A[v] = 1
    I[v] = i
  ++i
Find first element in A[S..S+U] with value not less than N
Reconstruct elements of the subset using matrices V and P.

Zero-initialize a boolean matrix with S+U rows and N columns\
  (U is the largest list value)
Zero-initialize an integer array A with S+U elements
i=0
For each value (v) in the list:
  For each j<S:
    If A[j] != 0 and (A[j + v] == 0) || (A[j + v] > A[j] + 1)):
      A[j + v] = A[j] + 1
      V[i,N-1,j + v] = v
      P[i,N-1,j + v] = (I[j,N-1],N-1)
      I[j+v,N-1] = i
  For k=N-2 .. 0:
    For each j<S:
      If M[k,j] and not M[k+1, j + v]:
        M[k+1, j + v] = true
        V[i,k+1,j + v] = v
        P[i,k+1,j + v] = (I[j,k],k)
        I[j+v,k+1] = i
  For each j<S:
    If M[N-1, j]:
      A[j] = N-1
  M[0,v] = true
  I[v,0] = i
  ++i
Find first nonzero element in A[N-1,S..S+U] (or the first element with smallest\
  value or any other element that suits both minimization criteria)
Reconstruct elements of the subset using matrices V and P.