生成合成的迭代算法

Question

我已经实现了一个算法，它在 Y 框中写出 X 项的所有可能组合（在组合学中，我相信它们被称为组合）。我使用递归函数编写了这个算法，因为它更容易跟踪我们正在放入项目的当前盒子以及剩余的项目数量。 这个算法给了我以下输出（4个盒子和3个项目）：

[3, 0, 0, 0], [2, 1, 0, 0], [2, 0, 1, 0], [2, 0, 0, 1], [1, 2, 0, 0], [1, 1, 1, 0], ..., [0, 0, 1, 2], [0, 0, 0, 3]

您可以想象，对于较大的 X 和 Y，合成的数量会增加很多。由于我不关心输入的顺序，我想并行化进一步的计算，但我不能这样做在递归函数上（我尝试通过保存递归状态来做到这一点，但这相当混乱，尽管它可以工作，但它真的很慢）。 所以，我想知道是否可以迭代地重写相同的函数（使用for 循环），以便我可以并行化它。 （要记住的一点是，优化也很重要，因为我需要运行大 X 和 Y 的函数）我的递归函数写在下面：

public void charArrangements (int boxes, int items, String strBuild) {
        if (boxes > 1) {
            for (int i = 0; i <= items; i++) {
                String ss = strBuild + (items - i) + ";";
                charArrangements(boxes - 1, i, ss);
            }
        }
        else {
            String ss = strBuild + items;
            List<Integer> charArrangement = new ArrayList<Integer>();
            charArrangement = Stream.of(ss.split(";")).map(Integer::parseInt).collect(Collectors.toList());

            doCalculations(charArrangement);
        }
} 

Answer 1

我认为你需要这个。让我们试试

public void charArrangements (int boxes, int balls, String strBuild) {
    for(int j=boxes;j>1;j--){
        for (int i = 0; i <= balls; i++) {
            String ss = strBuild + (balls - i) + ";";
            }
    }
}

在此之后，您可以执行 else 子句中的逻辑。

Answer 2

你可以在不同的线程和join当前线程中调用递归调用，例如：

public void charArrangements (int boxes, int balls, String strBuild) {
    if (boxes > 1) {
        for (int i = 0; i <= balls; i++) {
            String ss = strBuild + (balls - i) + ";";
            final int count = i;
            try{
                Runnable r = new Runnable() {
                    @Override
                    public void run() {
                        charArrangements(boxes - 1, count, ss);
                    }
                };
                Thread t = new Thread(r);
                t.start();
                t.join();
            }catch(Exception e){
                throw new RuntimeException(e);
            }
        }
    }
    else {
        String ss = strBuild + balls;
        List<Integer> charArrangement = new ArrayList<Integer>();
        charArrangement = Stream.of(ss.split(";")).map(Integer::parseInt).collect(Collectors.toList());
    }
}

附：删除了文件写入部分。

Answer 3

线程就像

public void charArrangements (int boxes, int balls, String strBuild) {
    ArrayList<myThread> arr=new ArrayList<>();//fill arraylist
    for(int j=boxes;j>1;j--){
        arr.get(j).start();
    }
}



//put this login in your threads run() method
public void someFunc(int balls, String strBuild)
{
    for (int i = 0; i <= balls; i++) {
        String ss = strBuild + (balls - i) + ";";
        }
}

Answer 4

为什么不能并行化递归函数？使用主线程遍历前 N 级（最好的 N 取决于您的问题空间），然后让并发工作人员处理 N+1 级及更高级别。

Answer 5

听起来您希望能够更直接地访问累积解决方案的状态；例如，能够保存和恢复它，而不必每次都重建它。实现此目的的一种方法是使用字典生成。

我建议首先创建没有任何零的数字分区，然后添加零并使用已知的简单算法进行下一个字典排列，您可以轻松地在线查找。这是一个将 5 件商品分装到 7 个盒子中的示例：

Order partitions in decreasing order by number of parts

[0,0,1,1,1,1,1] -> generate all lexicographic permutations
[0,0,0,1,1,1,2] -> generate all lexicographic permutations
[0,0,0,0,1,2,2] -> ...

以下是我想出的一种用于反向下一个相等大小的字典分区的算法，也许它可以改进或更正（我们将其反转，以便我们可以在下一步中从排名最低的排列开始）：

(0) The first partition is either k (n/k)'s if k divides n,
    or (remainder of n/k) (n/k + 1)'s and (k - remainder of n/k)'s (n/k)'s
    to their left.

(1) Find the leftmost part, l, greater than 1

(2) If l is the rightmost part, we're done.
    Otherwise, decrement l and increment the leftmost part, r,
      right of l that is lower than its right neighbour.
      If r is not found, increment the rightmost part and
        set the rest of the partition according to
        instruction (0), where k and n now would be 
        (k - 1) and (n - rightmost part), respectively.

[0,0,0,0,1,2,2] -> generate all lexicographic permutations
[0,0,0,0,1,1,3] -> ...
etc.

Answer 6

一个简单但丑陋的迭代算法，用于以逆字典顺序枚举弱 k 组合，可能如下所示：

static void weakCompositions(int n, int k, Consumer<int[]> callback) {
    assert n >= 0: n;
    assert k >= 0: k;

    if (k == 0)
        return;

    int C[], i, x;
    C = new int[k];
    C[0] = n;

    while (true) {
        callback.accept(C);

        i = k - 2;

        while (i >= 0 && C[i] == 0)
            i--;

        if (i < 0)
            break;

        C[i]--;
        x = C[k - 1] + 1;
        C[k - 1] = 0;
        C[i + 1] = x;
    }
}

其中n 是项目数，k 是盒子数。

不确定它是否适合并行化。

基本思路是在数组的前缀中找到最右边的非零值的位置（即不包括最后一项）； “转移” 1 从那个位置到它的直接权利；并且，在那个新位置，吸收它右边的所有值（如果有的话，它应该只是数组中的最后一个值，通过构造）。

我相信应该可以跟踪数组前缀的最右边的非零值，而不必为生成的每个合成进行扫描。这样做还可以更轻松地分析算法并查看它是否是常数摊销时间。

最后，number of weak k-compositions 由(n + k - 1)! / n! / (k - 1)! 给出。您提到您的最终问题空间是 75 个盒子中的 11 个项目，即超过 21 万亿个对象！即使使用并行化，这似乎......令人生畏。祝你好运！