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 * n而不是1 * 3。而不是两个，我有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);
}

结果：

Answer 2

如果我理解正确并且您有M个阵列，每个阵列都有N个元素，并且想要找到所有可能的组合，那么您需要查看backtracking方法。

您可以这样实现：

将索引的数组（I）保存到N个向量中，最初设置为0
在每个步骤中，将一个添加到此索引数组的第一个元素
现在，如果第一个元素模n为0，则将此元素设置为0并移动到数组中的下一个元素并递增它
对当前元素重复步骤3
如果超过最后一个元素，那么就完成了
如果没有，请打印当前配置并返回到I

有关两个元素的两个数组如何工作的说明是：

[0 0] - ＆gt;打印
+1 - ＆gt; [1 0] - ＆gt;打印
+1 - ＆gt; [2 0]（％2） - ＆gt; [0 1] - ＆gt;打印
+1 - ＆gt; [1 1] - ＆gt;打印
+1 - ＆gt; [2 1]（％2） - ＆gt; [0 2]（％2） - ＆gt; [0 0] - ＆gt;出口

你可以在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

所有可能的总和

2 个答案: