如何按列表顺序生成指定大小的不重复组合并满足最小使用规则

问题核心约束 #

• 总元素数必须为18，元素来自4个固定列表，每个元素仅能使用一次
• 同一列表的元素在最终组合中必须保持原列表的先后顺序（如RB2不能出现在RB1之前）
• 数量下限：qb≥1，rb≥2，wr≥3，te≥1；数量上限为各列表的元素总数

解决思路 #

先筛选出所有满足总元素数和上下限要求的数量组合（即从每个列表选多少个元素），再针对每个数量组合生成合法的元素排列（保证同一列表元素顺序不变）。

方案1：选取各列表连续前缀（性能最优） #

如果允许仅选取每个列表的前k个元素（如选2个qb则只能是QB1、QB2），这种方式组合量最小，适合性能有限的设备：

# 原始列表定义
qb = ['QB1', 'QB2', 'QB3']
rb = ['RB1', 'RB2', 'RB3', 'RB4', 'RB5', 'RB6', 'RB7', 'RB8', 'RB9', 'RB10']
wr = ['WR1', 'WR2', 'WR3', 'WR4', 'WR5', 'WR6', 'WR7', 'WR8', 'WR9', 'WR10', 'WR11']
te = ['TE1', 'TE2', 'TE3', 'TE4', 'TE5']

# 第一步：生成所有合法的数量组合(x,y,z,w)，对应qb、rb、wr、te的选取数量
valid_counts = []
for x in range(1, 4):
    for w in range(1, 6):
        remaining = 18 - x - w
        if remaining < 5:  # rb≥2 + wr≥3，剩余至少5个
            continue
        # 计算rb的合法取值范围
        min_y = max(2, remaining - 11)  # wr最多选11个，所以rb至少要选remaining-11
        max_y = min(10, remaining - 3)  # wr最少选3个，所以rb最多选remaining-3
        if min_y > max_y:
            continue
        for y in range(min_y, max_y + 1):
            z = remaining - y
            if 3 <= z <= 11:
                valid_counts.append((x, y, z, w))

# 第二步：生成多序列的交错排列，保证每个序列内部顺序不变
def generate_ordered_permutations(sequences):
    if not sequences:
        yield []
        return
    for i in range(len(sequences)):
        seq = sequences[i]
        if not seq:
            continue
        # 取出当前序列的第一个元素，递归处理剩余序列
        new_seqs = sequences[:i] + [seq[1:]] + sequences[i+1:]
        for perm in generate_ordered_permutations(new_seqs):
            yield [seq[0]] + perm

# 遍历所有数量组合，生成并输出结果
for x, y, z, w in valid_counts:
    qb_selected = qb[:x]
    rb_selected = rb[:y]
    wr_selected = wr[:z]
    te_selected = te[:w]
    for combo in generate_ordered_permutations([qb_selected, rb_selected, wr_selected, te_selected]):
        print(combo)

方案2：选取任意k个元素（保持原列表顺序） #

如果需要从列表中选取任意k个元素（只要保持原顺序，比如选RB1、RB3而跳过RB2），可以用以下代码，但注意组合量会非常大，可能导致性能问题：

from itertools import combinations

# 原始列表定义
qb = ['QB1', 'QB2', 'QB3']
rb = ['RB1', 'RB2', 'RB3', 'RB4', 'RB5', 'RB6', 'RB7', 'RB8', 'RB9', 'RB10']
wr = ['WR1', 'WR2', 'WR3', 'WR4', 'WR5', 'WR6', 'WR7', 'WR8', 'WR9', 'WR10', 'WR11']
te = ['TE1', 'TE2', 'TE3', 'TE4', 'TE5']

# 第一步：生成所有合法的数量组合(x,y,z,w)
valid_counts = []
for x in range(1, 4):
    for w in range(1, 6):
        remaining = 18 - x - w
        if remaining < 5:
            continue
        min_y = max(2, remaining - 11)
        max_y = min(10, remaining - 3)
        if min_y > max_y:
            continue
        for y in range(min_y, max_y + 1):
            z = remaining - y
            if 3 <= z <= 11:
                valid_counts.append((x, y, z, w))

# 生成列表中所有k元素的合法组合（保持原顺序）
def get_list_combinations(lst, k):
    return combinations(lst, k)

# 生成交错排列，保证每个组合内部元素顺序不变
def generate_ordered_permutations(sequences):
    if not sequences:
        yield []
        return
    for i in range(len(sequences)):
        seq = sequences[i]
        if not seq:
            continue
        new_seqs = sequences[:i] + [seq[1:]] + sequences[i+1:]
        for perm in generate_ordered_permutations(new_seqs):
            yield [seq[0]] + perm

# 遍历所有可能的元素组合和排列
for x, y, z, w in valid_counts:
    for qb_combo in get_list_combinations(qb, x):
        for rb_combo in get_list_combinations(rb, y):
            for wr_combo in get_list_combinations(wr, z):
                for te_combo in get_list_combinations(te, w):
                    for final_combo in generate_ordered_permutations([list(qb_combo), list(rb_combo), list(wr_combo), list(te_combo)]):
                        print(final_combo)

性能提示 #

• 方案1的组合量远小于方案2，优先推荐使用，尤其是设备性能有限时
• 如果需要保存结果，建议将输出写入文件而非直接打印，避免卡顿

内容的提问来源于stack exchange，提问作者nzylak