Meu objetivo é encontrar o menor número possível de subconjuntos [a-f] para compor o conjunto completo A.

A = set([1,2,3,4,5,6,7,8,9,10]) # full set


#--- below are sub sets of A ---

a = set([1,2])
b = set([1,2,3])
c = set([1,2,3,4])
d = set([4,5,6,7])
e = set([7,8,9])
f = set([5,8,9,10])

Na realidade, o conjunto pai A com o qual estou lidando contém 15k elementos exclusivos, com 30k subconjuntos e esses subconjuntos variam em comprimentos de um único elemento único a 1.5k elementos únicos.

A partir de agora, o código que estou usando se parece mais ou menos com o seguinte e é incrivelmente lento:

import random


B = {'a': a, 'b': b, 'c': c, 'd': d, 'e': e, 'f': f}
Bx = B.keys()
random.shuffle(Bx)

Dict = {}

for i in Bx: # iterate through shuffled keys.
    z = [i]
    x = B[i]
    L = len(x)

    while L < len(A):
        for ii in Bx:
            x = x | B[ii]
            Lx = len(x)
            if Lx > L:
                L = Lx
                z.append(ii)

    try:
        Dict[len(z)].append(z)
    except KeyError:
        Dict[len(z)] = [z]

print Dict[min(Dict.keys()]

Isso é apenas para dar uma idéia da abordagem que adotei. Para maior clareza, deixei de lado uma lógica que minimiza as iterações em conjuntos que já são grandes demais e outras coisas assim.

Eu imagino que o Numpy seria MUITO bom nesse tipo de problema, mas não consigo pensar em uma maneira de usá-lo.