按大小升序排列的一组整数的 k 组合

Question

编程挑战：给定一组整数 [1, 2, 3, 4, 5] 我想在 Java 中以 升序 生成所有可能的 k 组合强>;例如

[1], [2], [3], [4], [5], [1, 2], [1, 3] ... [1, 2, 3, 4, 5]

生成所有组合然后对它们进行排序的递归解决方案相当容易，但我想有一种更有效的方法可以消除对额外排序的需求。

Answer 1

只要iterative deepening search。

void comb(int... items) {
    Arrays.sort(items);
    for (int k = 1; k <= items.length; k++) {
        kcomb(items, 0, k, new int[k]);
    }
}
public void kcomb(int[] items, int n, int k, int[] arr) {
    if (k == 0) {
        System.out.println(Arrays.toString(arr));
    } else {
        for (int i = n; i <= items.length - k; i++) {
            arr[arr.length - k] = items[i];
            kcomb(items, i + 1, k - 1, arr);
        }
    }
}

然后打电话给comb(10,20,30)。它将打印：

[10]
[20]
[30]
[10, 20]
[10, 30]
[20, 30]
[10, 20, 30]

Answer 2

有两种解释“升序”要求的方法。更宽松的解释是“在每个列表中，整数应该按升序出现”。更严格的解释是“列表需要按顺序给出”。我想这就是你想要的，但我想出了一种简单的迭代方法来满足更宽松的要求。

对于 n 个项目，计算所有 n 位数字。如果与某个项目对应的位存在，那么它就在结果列表中。

public static void displaySubsets(List<Integer> sortedInts) {
    int n=sortedInts.size();
    long combinations = 1 << n;
    for (int setNumber=0; setNumber<combinations; setNumber++) {
      List<Integer> aResult = new ArrayList<Integer>();
      for (int digit=0; digit<n; digit++) {
        if ((setNumber & (1<<digit)) > 0) {
          aResult.add(sortedInts.get(digit));
        }
      }
      System.out.println(aResult.toString()+", ");
    }
  }

1,2,3,4,5 的结果是： [], [1], [2], [1, 2], [3], [1, 3], [2, 3], [1, 2, 3], [4], [1, 4], [2, 4], [1, 2, 4], [3, 4], [1, 3, 4], [2, 3, 4], [1, 2, 3, 4], [5], [1, 5], [2, 5], [1, 2, 5], [3, 5], [1, 3, 5], [2, 3, 5], [1, 2, 3, 5], [4, 5], [1, 4, 5], [2, 4, 5], [1, 2, 4, 5], [3, 4, 5], [1, 3, 4, 5], [2, 3, 4, 5], [1、2、3、4、5]

是的，我知道，我因为不使用递归而失分。

Answer 3

我对此进行了更多思考，并意识到使用动态编程方法可以有效地完成它。下面是我生成的迭代解决方案，它使用Queue 来保持状态（尽管可以使用Stack 代替）。

我相信这比递归迭代深化搜索效率更高，因为它不会涉及在生成过程中重新访问现有状态；它使用队列记住以前的状态，并使用这些状态来生成连续的状态。

性能比较

Algorithm                    | 5 elems | 10 elems | 20 elems
--------------------------------------------------------------------------
Recursive (#recursions)      | 62      | 2046     | 2097150
Dynamic   (#loop iterations) | 32      | 1024     | 1048576

代码

public class Test {
    private static class Pair {
        private final List<Integer> result;
        private final int index;

        private Pair(List<Integer> result, int index) {
            this.result = result;
            this.index = index;
        }

        public List<Integer> getResult() {
            return result;
        }

        public int getIndex() {
            return index;
        }
    }

    public static void main(String[] args) {
        List<Integer> items = Arrays.asList(1, 2, 3, 4, 5);
        foo(items);
    }

    private static void foo(List<Integer> items) {
        Queue<Pair> queue = new LinkedList<Pair>();
        queue.add(new Pair(Collections.<Integer>emptyList(), 0));

        while (!queue.isEmpty()) {
            Pair pair = queue.poll();

            System.err.println(pair.getResult());

            if (pair.getResult().size() < items.size()) {
                for (int i=pair.getIndex(); i<items.size(); ++i) {
                    List<Integer> copy = new LinkedList<Integer>(pair.getResult());
                    copy.add(items.get(i));
                    queue.add(new Pair(copy, i + 1));
                }
            }
        }
    }
}

Answer 4

生成组合比排序花费的时间要长得多，并且在给定 n*log(n) 排序时间的情况下对 100,000 个数字进行排序并不需要那么长时间。您正在预优化。这很糟糕。