实际上，你可以将元组编码为整数。因为你提到整数的范围是[0, 50]，并且可能有多达5个这样的整数，所以创建了一个51^5 = 345,025,251值的范围，这是完全可行的。
要理解我们如何进行这种编码，请考虑十进制数的工作原理-123意味着1*100 + 2*10 + 1*1。每个数字乘以基数（10）的某个幂，对应于它的位置。每个数字只有一种表示，因为每个数字都小于基数（10）本身。我们可以做类似的事情。我们可以选择一个足够大的基数，比如100，然后将元组中的每个值乘以基数的相应幂。举下面的例子：

(1, 4, 7)
-> 1*100^2 + 4*100^1 + 7*100^0
-> 1*10000 + 4*100   + 7
-> 10407

这项工作本身工作得很好，但是无论您使用的是整数情况下的任何底层求解器，都可能在较小的数字上表现得更好，所以我们真的应该尽可能地尝试“压缩”表示。这意味着选择尽可能小的基数。事实上，这意味着为混合基数系统选择多个基数。不需要太多细节，这意味着如果元组的一个位置只跨越一个小的整数间隔，我们不会为那些在特定元组位置不存在的值“浪费”空间。这可能看起来像什么，对于一个任意的例子：

(1, 4, 7, 11)
-> 1*22*7*15 + 4*22*7 + 7*22 + 11*1
-> 2310      + 616    + 154  + 11
-> 3091
// Here we arbitrarily choose the radices [22, 7, 15]
// In practice, we actually choose meaningful (and minimal) radices

此外，我们还可以减去元组位置上的最小值，以进一步缩小值。我们只需要记住在将值转换回元组时将适当的偏移量乘以元素数。
所有这一切都说，这里的代码就是这样做的：

from functools import wraps

def transform_tuples(func):
    @wraps(func)
    def inner(arr, n):
        if n == 0 or not arr:
            return set()
        
        groups = [(max(g)-min(g), min(g)) for g in zip(*arr)]
        
        def encode(tup):
            val = 0
            for (size, low), elem in zip(groups, tup):
                val *= size * n + 1
                val += elem - low
            return val
            
        def decode(val):
            tup = []
            for size, low in groups[::-1]:
                val, part = divmod(val, size * n + 1)
                tup.append(part + low * n)
            return tuple(tup[::-1])
            
        result = func([encode(tup) for tup in arr], n)
        return [decode(val) for val in result]
    
    return inner

这是一个装饰器--你将它应用于函数，解决了最初的基于整数的问题，它将把函数转换成一个对元组进行操作的函数。
例如，从上面链接的相关问题中取出Kelly1solution，我们可以装饰它，然后它将在元组上工作：

@transform_tuples
def Kelly1(a, n):
    sums = {0}
    for _ in range(n):
        sums = {s + x for s in sums for x in a}
    return sums

以你为例：

tuples = [(1,0,0), (2,1,1), (3,3,2)]
k = 2

print(Kelly1(tuples, k))

产生：

[(2, 0, 0), (5, 4, 3), (3, 1, 1), (6, 6, 4), (4, 2, 2), (4, 3, 2)]

因此，您可以选择最快的实现，根据需要调整/优化它，然后将其修饰为对元组进行操作。