Question

给定一个上限d和一个整数数组，返回其元素总和为<= d的所有子集（作为数组），并且我们不能向其添加任何其他元素数组，以免<= d被违反。

示例：

d = 4;
int[] arr = {1, 2, 3, 4, 5};

int[][] solution = findAllMaximalSubsets(arr, d);

System.out.println(Arrays.deepToString(solution));

Output: { {1, 2}, {1, 3}, {4} }

此方法findAllMaximalSubsets(int[] arr, d)是我正在研究的另一种算法的子程序。我怀疑解决方案是Np-ish，这很好。

目前我没有办法解决这个问题：/

Answer 1

不同意Stack Overflow不是代码为您编写的地方的评论。我想我可以在代码中更好更准确地解释细节而不是文字，所以我在这里提供代码。我也承认写这篇文章很乐意（这本身也不是发布它的借口）。

我这里没有使用任何动态编程或任何图形。我是使用Dawood Ibn Kareem的想法尝试使用和不使用x并使用递归来解决问题的其余部分。

在每次调用递归方法时，我传递数组a和上限capacity;每个电话都是一样的。我传递了一个部分解决方案，告诉我们当前正在构建的子集中包含哪些先前考虑的元素，以及为方便起见所包含的元素的总和。最后，我传递了迄今为止遗漏的最小元素。这将允许我最后检查我们是否最终得到一个我们无法添加其他元素的集合。

我没有给你你想要的回报类型，但我相信如果它很重要，你就会改变自己。原因是我假设数组元素是不同的，即使有些元素是相等的。如果数组是{ 1, 3, 2, 3, 5 }并且解决方案包含{ 1, 3 }，则您不知道我采用了哪3个。所以我给你一个布尔数组{ true, true, false, false, false }（如果我拿第3个）或{ true, false, false, true, false }（如果我拿第二个3）（实际上我会给你们两个）。

/**
 * Calculates all subsets of a that have a sum <= capacity
 * and to which one cannot add another element from a without exceeding the capacity.
 * @param a elements to put in sets;
 * even when two elements from a are equal, they are considered distinct
 * @param capacity maximum sum of a returned subset
 * @return collection of subsets of a.
 * Each subset is represented by a boolean array the same length as a
 * where true means that the element in the same index in a is included,
 * false that it is not included.
 */
private static Collection<boolean[]> maximalSubsetsWithinCapacity(int[] a, int capacity) {
    List<boolean[]> b = new ArrayList<>();
    addSubsets(a, capacity, new boolean[0], 0, Integer.MAX_VALUE, b);
    return b;
}

/** add to b all allowed subsets where the the membership for the first members of a is determined by paritalSubset
 * and where remaining capacity is smaller than smallestMemberLeftOut
 */
private static void addSubsets(int[] a, int capacity, boolean[] partialSubset, int sum,
        int smallestMemberLeftOut, List<boolean[]> b) {
    assert sum == IntStream.range(0, partialSubset.length)
            .filter(ix -> partialSubset[ix])
            .map(ix -> a[ix])
            .sum() 
            : Arrays.toString(a) + ' ' + Arrays.toString(partialSubset) + ' ' + sum;
    int remainingCapacity = capacity - sum;
    if (partialSubset.length == a.length) { // done
        // check capacity constraint: if there’s still room for a member of size smallestMemberLeftOut,
        // we have violated the maximality constraint
        if (remainingCapacity < smallestMemberLeftOut) { // OK, no more members could have been added
            b.add(partialSubset);
        }
    } else {
        // try next element from a.
        int nextElement = a[partialSubset.length];
        // i.e., decide whether  should be included.
        // try with and without.

        // is including nextElement a possibility?
        if (nextElement <= remainingCapacity) { // yes
            boolean[] newPartialSubset = Arrays.copyOf(partialSubset, partialSubset.length + 1);
            newPartialSubset[partialSubset.length] = true; // include member
            addSubsets(a, capacity, newPartialSubset, sum + nextElement, smallestMemberLeftOut, b);
        }

        // try leaving nextElement out
        boolean[] newPartialSubset = Arrays.copyOf(partialSubset, partialSubset.length + 1);
        newPartialSubset[partialSubset.length] = false; // exclude member
        int newSmallestMemberLeftOut = smallestMemberLeftOut;
        if (nextElement < smallestMemberLeftOut) {
            newSmallestMemberLeftOut = nextElement;
        }
        addSubsets(a, capacity, newPartialSubset, sum, newSmallestMemberLeftOut, b);
    }

在一些地方有点棘手。我希望我的评论会帮助你完成它。否则请询问。

让我们试一试：

    int[] a = { 5, 1, 2, 6 };
    Collection<boolean[]> b = maximalSubsetsWithinCapacity(a, 8);
    b.forEach(ba -> System.out.println(Arrays.toString(ba)));

此代码打印：

[true, true, true, false]
[false, true, false, true]
[false, false, true, true]

[true, true, true, false]表示5,1和2的子集。总和为8，因此这恰好符合8的容量（d）。
[false, true, false, true]表示1和6，总和为7，我们无法添加2或者我们会超出容量
最后[false, false, true, true]表示2和6，并且完全符合容量d。

我相信这会在你的限制范围内耗尽可能性。

Answer 2

您可以找到如下所示的所有子集组合，并添加所有子集元素并与d进行比较。

===================

  private static void findAllMaximalSubsets(int[] arr,int d) {


   for(int i=0;i<arr.length;i++) {
       for (int j =i;j< arr.length;j++) {
           int sum = 0;
           for (int k = i; k <= j; k++) {
               sum = sum + arr[k];
           }
           if (sum <= d) 
               //add the array elements from k o j to the 2D arry
       }
   }    
}

给定一个整数数组，找到所有＆＃34; maximal＆＃34;子集

2 个答案: