所有可能的总和

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
    }
}

如果预期结果是一个二维数组，其中包含每个总和的结果，则这是一个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个元素，并且想要找到所有可能的组合，则需要查看回溯方法。

您可以这样实现：

1. 将索引数组（I）保留在N个向量中，初始设置为0
2. 在每一步中，向此索引数组的第一个元素添加一个
3. 现在，如果第一个元素的模n为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