我不能完全遵循代码中的逻辑来查看您做错了什么，但我提出了这个似乎可以满足您的要求：

import itertools  # for itertools.combinations
import functools  # for functools.reduce
n=3
m=9
# track a list of valid combinations; a valid combination has
# elements that don't have more than 1 value in common with other
# valid combinations
valid = []
# loop through every possible combination given (m, n)
for combo in itertools.combinations(range(m), n):
    # check each possible combination against every valid combination
    for v in valid:
        if len(v & set(combo)) > 1:
            break  # this combo has more than 1 element in common
    else:
        valid.append(set(combo))
# (m,n) is valid if all members of m are represented in the list of
# valid combinations
if len(functools.reduce(set.union, valid)) == m:
    print(f'({m}, {n}) is valid and produces {len(valid)} combinations')
    print(valid)

个字符

编辑：根据您的评论，为了有效地生成大量的有效组合，这里有一个替代实现。这个版本存储了少量的状态，并根据请求输出有效的组合。它仍然需要花费很长时间来生成所有的m，n = 96，6值，但每个单独的组合都可以执行，而不必计算它们。

import itertools
def valid_combos(m, n):
    seen_pairs = set()  # this will only grow to C(m,2) elements
    # loop through every possible combination given (m, n)
    for combo in itertools.combinations(range(m), n):
        combo_pairs = set()
        for pair in itertools.combinations(combo, 2):
            if pair in seen_pairs:
                break
            combo_pairs.add(pair)
        else:
            seen_pairs |= combo_pairs
            yield combo
for count, combo in enumerate(valid_combos(96, 5), start=1):
    print(combo)
print(f'{count=}')

型
可以通过在生成器中使用多线程或DISC来进行一些优化。可以通过实现itertools.combinations的自定义版本来实现进一步的优化，其中可以将seen_pairs的检查集成到逻辑中，从而避免生成无效组合。

上次编辑：我尝试了一个修改过的itertools.combinations的参考实现，以从输入空间中删除块。下面是m,n=96,6的计时结果。

import itertools
def pruned_combinations(n, r, seen_pairs):
    """modified itertools.combinations reference implementation:
       https://docs.python.org/3/library/itertools.html#itertools.combinations
    """
    if r > n:
        return
    indices = list(range(r))
    yield tuple(indices)
    while True:
        for i in reversed(range(r)):
            if indices[i] != i + n - r:
                break
        else:
            return
        indices[i] += 1
        for j in range(i+1, r):
            indices[j] = indices[j-1] + 1
        # prune, if possible
        for z in range(1, r-2):
            if tuple(indices[z-1:z+1]) in seen_pairs:
                if indices[z] != z+n-r:
                    indices[z] += 1
                    for j in range(z+1, r):
                        indices[j] = indices[j-1] + 1
                break
        else:
            yield tuple(indices)
def valid_combos(m, n):
    seen_pairs = set()  # this will only grow to C(m,2) elements
    for combo in pruned_combinations(m, n, seen_pairs):
        combo_pairs = set(itertools.combinations(combo, 2))
        for pair in combo_pairs:
            if pair in seen_pairs:
                break
        else:
            seen_pairs |= combo_pairs
            yield combo
import timeit
start_time = timeit.default_timer()
for count, combo in enumerate(valid_combos(96, 6), start=1):
    pass
print(f'{count=}')
print(f'time: {timeit.default_timer()-start_time:.2f} seconds')

count=211
time: 32.66 seconds