所有可能的总和

Question

我有两个矩阵：

A=[1 2 3];
B=[4 5 6]; 

它们总和的所有可能组合是

[1+4 1+5 1+6; 2+4 2+5 2+6;3+4 3+5 3+6]

现在我的矩阵维度不是 1*3，而是 1*n。而不是两个，我有 N 个。

我怎样才能找到它们所有可能的求和矩阵组合？

Answer 1

遍历数组：

for ( every element a in A ) {
    for ( every element b in B ) {
        consider s = a + b 
        use s
    }
}

如果预期结果是包含每个求和结果的 2D 数组，则以下是 JavaScript 实现：

var A = [1,2,3,10];
var B = [4,5,6];

var M = new Array(A.length);
for ( var i = 0 ; i < A.length ; i++ ) {
    M[i] = new Array(B.length);
    for ( var j = 0 ; j < B.length ; j++ ) {        
        M[i][j] = A[i] + B[j];
    }        
}

for ( var i = 0 ; i < A.length ; i++ ) {
    var line = '';
    for ( var j = 0 ; j < B.length ; j++ ) {
        line += M[i][j]+'  ';
    }
    console.log(line);
}

结果：

5  6  7  
6  7  8  
7  8  9  
14  15  16 

Answer 2

如果我理解正确并且你有 M 个数组，每个数组都有 N 个元素，并且想要找到所有可能的组合，你想看看 backtracking 方法。

您可以这样实现：

1. 在 N 个向量中保留一个索引数组 (I)，最初设置为 0
2. 在每个步骤中，将一个添加到此索引数组的第一个元素
3. 现在如果第一个元素的模数为 0，则将此元素设置为 0，然后移动到数组中的下一个元素并递增它
4. 对当前元素重复第 3 步
5. 如果超过了最后一个元素，那么你就完成了
6. 如果没有，打印当前配置，返回到I中的第一个位置

这对于具有两个元素的两个数组如何工作的一个说明是：

1. [0 0] -> 打印
2. +1 -> [1 0] -> 打印
3. +1 -> [2 0] (%2) -> [0 1] -> 打印
4. +1 -> [1 1] -> 打印
5. +1 -> [2 1] (%2) -> [0 2] (%2) -> [0 0] -> 退出

你可以像这样在 Python 中做到这一点

def printSol(As, I):
    print I, '-->',
    for p in range(len(As)):
        print As[p][I[p]],
    print

def main():

    As = [
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]]

    n = len(As[0])
    I = [0] * n
    pos = 0

    printSol(As, I)

    while True:
        I[pos] += 1

        while I[pos] % n == 0:
            I[pos] = 0
            pos += 1
            if pos >= len(I):
                return
            I[pos] += 1
        pos = 0

        printSol(As, I)

if __name__ == '__main__':
   main()

生成所有可能的 27 种组合：

[0, 0, 0] --> 1 4 7
[1, 0, 0] --> 2 4 7
[2, 0, 0] --> 3 4 7
[0, 1, 0] --> 1 5 7
[1, 1, 0] --> 2 5 7
[2, 1, 0] --> 3 5 7
[0, 2, 0] --> 1 6 7
[1, 2, 0] --> 2 6 7
[2, 2, 0] --> 3 6 7
[0, 0, 1] --> 1 4 8
[1, 0, 1] --> 2 4 8
[2, 0, 1] --> 3 4 8
[0, 1, 1] --> 1 5 8
[1, 1, 1] --> 2 5 8
[2, 1, 1] --> 3 5 8
[0, 2, 1] --> 1 6 8
[1, 2, 1] --> 2 6 8
[2, 2, 1] --> 3 6 8
[0, 0, 2] --> 1 4 9
[1, 0, 2] --> 2 4 9
[2, 0, 2] --> 3 4 9
[0, 1, 2] --> 1 5 9
[1, 1, 2] --> 2 5 9
[2, 1, 2] --> 3 5 9
[0, 2, 2] --> 1 6 9
[1, 2, 2] --> 2 6 9
[2, 2, 2] --> 3 6 9