嵌套递归，找到所有可能的片数

Question

给定一个示例输入：

[
    {"id":1,"currentBlack":1,"currentWhite":0,"max":1},
    {"id":2,"currentBlack":0,"currentWhite":1,"max":1},
]

输出输入的所有可能状态，其中 currentBlack 和 currentWhite 可以具有从其初始值到最大值范围内的任何值。

此示例的正确输出：

[
    [
        {"id":1,"currentBlack":1,"currentWhite":0,"max":1},
        {"id":2,"currentBlack":0,"currentWhite":1,"max":1},
    ],
    [
        {"id":1,"currentBlack":1,"currentWhite":1,"max":1},
        {"id":2,"currentBlack":0,"currentWhite":1,"max":1},
    ],
    [
        {"id":1,"currentBlack":1,"currentWhite":1,"max":1},
        {"id":2,"currentBlack":1,"currentWhite":1,"max":1},
    ],
    [
        {"id":1,"currentBlack":1,"currentWhite":0,"max":1},
        {"id":2,"currentBlack":1,"currentWhite":1,"max":1},
    ]
]

实际输入的最大值在 1 到 8 之间，并且输入数组中的对象要多得多。我的尝试如下（大量评论）：

function allPossibleCounts(pieceCounts) {//pieceCounts is the input
        var collection = []; //used to collect all possible values
        recursiveCalls(pieceCounts); //runs recursive function
        return collection; //returns result

        function recursiveCalls(pieceCounts) {
            //if pieceCounts is already in collection then return, not yet implemented so duplicates are currently possible
            collection.push(pieceCounts);//inputs a potential value

            console.log(JSON.stringify(pieceCounts));//this is successfully logs the correct values
            console.log(JSON.stringify(collection));//collection isn't correct, all values at the top of the array are copies of each other

            for (let n in pieceCounts) {//pieceCounts should be the same at the start of each loop within each scope, aka pieceCounts should be the same at the end of this loop as it is at the start

                subBlackCall(pieceCounts);
                function subBlackCall(pieceCounts) {
                    if (pieceCounts[n].currentBlack < pieceCounts[n].max) {
                        pieceCounts[n].currentBlack++;//increment
                        recursiveCalls(pieceCounts);
                        subBlackCall(pieceCounts);//essentially you're either adding +1 or +2 or +3 ect all the way up to max and calling recursiveCalls() off of each of those incremented values
                        pieceCounts[n].currentBlack--;//decrement to return pieceCounts to how it was at the start of this function
                    }
                }

                subWhiteCall(pieceCounts);
                function subWhiteCall(pieceCounts) {
                    if (pieceCounts[n].currentWhite < pieceCounts[n].max) {
                        pieceCounts[n].currentWhite++;
                        recursiveCalls(pieceCounts);
                        subWhiteCall(pieceCounts);
                        pieceCounts[n].currentWhite--;
                    }
                }
            }
        }
    }

但目前我的尝试输出为复制数组的这种不敬的混乱

[[{"id":1,"currentBlack":1,"currentWhite":1,"max":1},{"id":2,"currentBlack":1,"currentWhite":1,"max":1}],[{"id":1,"currentBlack":1,"currentWhite":1,"max":1},{"id":2,"currentBlack":1,"currentWhite":1,"max":1}],[{"id":1,"currentBlack":1,"currentWhite":1,"max":1},{"id":2,"currentBlack":1,"currentWhite":1,"max":1}],[{"id":1,"currentBlack":1,"currentWhite":1,"max":1},{"id":2,"currentBlack":1,"currentWhite":1,"max":1}],[{"id":1,"currentBlack":1,"currentWhite":1,"max":1},{"id":2,"currentBlack":1,"currentWhite":1,"max":1}]]

编辑：工作代码：https://pastebin.com/qqFTppsY

Answer 1

pieceCounts[n] 始终引用一个对象。您应该重新创建 pieceCount 以作为不同的对象保存到集合中。例如，您可以添加

pieceCounts = JSON.parse(JSON.stringify(pieceCounts)); // just clone 

recursiveCalls 函数的开头。

Answer 2

为避免转换为 JSON 并返回，我建议使用 Object.assign 结合阵列上的 map 执行更深的复制：

function allPossibleCounts(pieceCounts) {
    var result = [],
        current = deeperCopy(pieceCounts);

    function deeperCopy(arr) {
        return arr.map( row => Object.assign({}, row) );
    }

    function recurse(depth) {
        // depth: indication of which value will be incremented. Each "row" has 
        // 2 items (black/white), so when depth is even, it refers to black, when 
        // odd to white. Divide by two for getting the "row" in which the increment
        // should happen.
        var idx = depth >> 1, // divide by 2 for getting row index
            prop = depth % 2 ? 'currentWhite' : 'currentBlack', // odd/even
            row = pieceCounts[idx];
        if (!row) { // at the end of the array
            // Take a copy of this variation and add it to the results
            result.push(deeperCopy(current));
            return; // backtrack for other variations
        }
        for (var value = row[prop]; value <= row.max; value++) {
            // Set the value of this property
            current[idx][prop] = value;
            // Collect all variations that can be made by varying any of 
            //   the property values that follow after this one
            recurse(depth+1);
            // Repeat for all higher values this property can get.
        }
    }

    recurse(0); // Start the process
    return result;
}

// Sample input
var pieceCounts = [
    {"id":1,"currentBlack":1,"currentWhite":0,"max":1},
    {"id":2,"currentBlack":0,"currentWhite":1,"max":1},
];
// Get results
var result = allPossibleCounts(pieceCounts);
// Output
console.log(result);

.as-console-wrapper { max-height: 100% !important; top: 0; }

这个想法是使用递归：想象可以解决除第一个属性之外的所有属性的所有变体的问题。产生这些，然后将第一个属性值更改为下一个可能的值。再次重复所有变化的产生，等等。所有这些结果的组合将是第一个属性值也应该变化的解决方案。

这是递归的理想情况。当没有更多的属性值剩余时，递归停止：在这种情况下，只有一个解决方案；所有值都按原样设置的那个。可以添加到结果列表中。

属性可以这样枚举：

row  currentBlack   currentWhite
---------------------------------
 0       0               1
 1       2               3
 2       4               5
 3       6               7
                ...
 n      2n-2            2n-1

我们可以称这个数字为 depth，并在更深的递归的每一步增加它。给定深度，变化的属性定义为：

depth is even  => currentBlack
depth is odd   => currentWhite
row number = depth / 2 (ignoring the remainder)