Algorithm 生成列表组合的算法，每个列表之间交换的索引都包含元素

我有两个列表，每个列表包含

N

元素

让

N=9

：

[a1, b1, c1, d1, e1, f1, g1, h1, i1]
[a2, b2, c2, d2, e2, f2, g2, h2, i2]

让我们交换每个列表的第一个元素。有两种可能性：

[a1, b1, c1, d1, e1, f1, g1, h1, i1]
[a2, b2, c2, d2, e2, f2, g2, h2, i2]

[a2, b1, c1, d1, e1, f1, g1, h1, i1]
[a1, b2, c2, d2, e2, f2, g2, h2, i2]

[a1, b1, c1, d1, e1, f1, g1, h1, i1]
[a2, b2, c2, d2, e2, f2, g2, h2, i2]

[a2, b1, c1, d1, e1, f1, g1, h1, i1]
[a1, b2, c2, d2, e2, f2, g2, h2, i2]

[a1, b2, c1, d1, e1, f1, g1, h1, i1]
[a2, b1, c2, d2, e2, f2, g2, h2, i2]

[a2, b2, c1, d1, e1, f1, g1, h1, i1]
[a1, b1, c2, d2, e2, f2, g2, h2, i2]

对于每个可能性，让我们交换每个列表的第二个元素。有四种可能性：

[a1, b1, c1, d1, e1, f1, g1, h1, i1]
[a2, b2, c2, d2, e2, f2, g2, h2, i2]

[a2, b1, c1, d1, e1, f1, g1, h1, i1]
[a1, b2, c2, d2, e2, f2, g2, h2, i2]

[a1, b1, c1, d1, e1, f1, g1, h1, i1]
[a2, b2, c2, d2, e2, f2, g2, h2, i2]

[a2, b1, c1, d1, e1, f1, g1, h1, i1]
[a1, b2, c2, d2, e2, f2, g2, h2, i2]

[a1, b2, c1, d1, e1, f1, g1, h1, i1]
[a2, b1, c2, d2, e2, f2, g2, h2, i2]

[a2, b2, c1, d1, e1, f1, g1, h1, i1]
[a1, b1, c2, d2, e2, f2, g2, h2, i2]

等等

为2个列表和

M

列表生成所有组合的最快算法是什么？
这个特殊过程的名称是什么？

---

给定的组合总数是多少？

如果我读对了，你可以使用这样的东西（用JS编写）：

const arrayA=['a1'，'b1'，'c1'，'d1'，'e1'，'f1'，'g1'，'h1'，'i1']
常量数组B=['a2'，'b2'，'c2'，'d2'，'e2'，'f2'，'g2'，'h2'，'i2']
let results=[{a:arrayA，b:arrayB}]
for（设i=0；i

---

最终数字为2^N，在本例中为512，因为对于新形成的列表L1的每个位置，可以从第一个或第二个列表中选择一个元素，每个位置有两个选项。对应的第二个列表L2将通过获取未选择的元素来形成，并且这只能通过一种方式完成。因此，存在

2^N

组合，其中

N

是原始列表的长度

使用这种思想，很容易使用

2^N

二进制掩码编写生成器-对于从

0

到

2^N-1的每个
i
，我们将生成一个由该数字的二进制表示确定的列表。下面是一段python代码：

a = ['a1', 'b1', 'c1']
b = ['a2', 'b2', 'c2']
for i in range(2 ** len(a)):
  l1, l2 = [], []
  mask = i
  for j in range(len(a)):
    l1.append(a[j] if mask % 2 == 0 else b[j])
    l2.append(b[j] if mask % 2 == 0 else a[j])
    mask /= 2
  print(l1, l2)

印刷品

(['a1', 'b1', 'c1'], ['a2', 'b2', 'c2'])
(['a2', 'b1', 'c1'], ['a1', 'b2', 'c2'])
(['a1', 'b2', 'c1'], ['a2', 'b1', 'c2'])
(['a2', 'b2', 'c1'], ['a1', 'b1', 'c2'])
(['a1', 'b1', 'c2'], ['a2', 'b2', 'c1'])
(['a2', 'b1', 'c2'], ['a1', 'b2', 'c1'])
(['a1', 'b2', 'c2'], ['a2', 'b1', 'c1'])
(['a2', 'b2', 'c2'], ['a1', 'b1', 'c1'])

由于输出大小是O（N*2^N）

你无法生成比这更复杂的算法。

我认为总数是N*N。在你的例子中是9*9=81。我错了吗？@dimitrisv.Papadopoulos我想还有很多。可能是

2^9

或

2^18

？@Freancesco Menzani可能是这个？2^（更改位置的总数）在第一个示例中，您做了1次更改，有2^（1）=2个数组。在第二个示例中，您做了2次更改（a1-a2和b1-b2），结果有2^（2）=4个数组。如果您进行3次更改（a1-a2、b1-b2和c1-c2），您将有2^（3）=8个数组。你明白我的意思吗？所以，从技术上讲，对于每个索引，要么交换，要么不交换。对吗？@vivek_23这是对的，有两个列表。这只适用于两个输入数组。