在Python中动态初始化列表列表

我假设你有输入a ，并且你想输出以下可能性：input_list:list of listspossibility:list of lists

• 每个整数input_list
• 与以下列表数量相同的内部列表：kinput_list

您可以获得 的子列表长度的可能性，然后用 的整数对每个子列表收费。possibilityinput_list

设子列表的长度为 ： 。
我们也可以这样写：f = （x_1， x_2， ...， x_k）
设 n 个整数。我们想要每个整数，所以： n = x_0 + x_1 + ... + x_k
我们可以这样说： n = x_0 + （x_1 + ... + x_k） n = x_0 + x_1 + （x_2 + ... + x_k）

等等
我们知道如何解析 n = x_0，所以我们可以使用递归：

possibilityfilling_possibility = [len_1, len_2, ..., len_k]

def resolve_equation(n, k):
    def find_solutions_recursive(target, k, current_solution):
        if k == 1:
            current_solution.append(target)
            solutions.append(tuple(current_solution))
            current_solution.pop()
        else:
            for x in range(target + 1):
                current_solution.append(x)
                find_solutions_recursive(target - x, k - 1, current_solution)
                current_solution.pop()

    solutions = []
    find_solutions_recursive(n, k, [])
    return solutions

input_list = [[1, 2, 3, 4], [5, 6, 7], [8, 9]]
n = sum(map(len, input_list))
k = len(input_list)
filling_possibilities = resolve_equation(n, k)

print(filling_possibilities)

现在我们用 的整数列表的排列来收取 every 的费用。
可以使用 itertools 来描述排列：filling_possibilityinput_list

import itertools

integers = sum(input_list, [])
integers_distributions = itertools.permutations(integers)

print(list(integers_distributions))

而充电部分，对于相同的整数分布：input_list

filling = filling_possibilities[0]
# Distribute integers to the current `possibility`
possibility = [[] for _ in range(k)]
# the index in the list of integers `integers`
i = 0
for sublist_len, sublist in zip(filling, possibility):
    sublist.extend(integers[i:i+sublist_len])
    i += sublist_len

print(possibility)

全部混合在一起：

import itertools

def resolve_equation(n, k):
    def find_solutions_recursive(target, k, current_solution):
        if k == 1:
            current_solution.append(target)
            solutions.append(tuple(current_solution))
            current_solution.pop()
        else:
            for x in range(target + 1):
                current_solution.append(x)
                find_solutions_recursive(target - x, k - 1, current_solution)
                current_solution.pop()

    solutions = []
    find_solutions_recursive(n, k, [])
    return solutions

def mix_integers(input_list):
    n = sum(map(len, input_list))
    k = len(input_list)
    filling_possibilities = resolve_equation(n, k)
    integers = sum(input_list, [])

    possibilities = []
    for filling in filling_possibilities:
        # `integers_distributions` is exhausted on every iteration (generator)
        integers_distributions = itertools.permutations(integers)
        for distribution in integers_distributions:
            # Distribute integers to the current `possibility`
            possibility = [[] for _ in range(k)]
            # i is the index in the list of integers `distribution`
            i = 0
            for sublist_len, sublist in zip(filling, possibility):
                sublist.extend(distribution[i:i+sublist_len])
                i += sublist_len
            possibilities.append(possibility)
    return possibilities

mixed = mix_integers([[1, 2, 3], [4], [5, 6, 7]])
print(mixed)

但它非常缓慢。您可以尝试使用 .[[1, 2, 3, 4], [5, 6, 7], [8, 9]]