设一副包含点数A到K,四种花色的52张牌,将三张及以上同点数不同花色的牌组或者三张及以上的同花顺称为组合，求出给定一副20张以内的牌中，所能形成的最优的组合列表（最优即组合点数累加最大）

这个问题可以用回溯法（backtracking）来解决。回溯法是一种通过穷举所有可能情况来寻找问题解的算法。具体步骤如下：

1. 对于给定的牌，先将它们按点数分类，得到每个点数的牌的集合。
2. 从点数最小的牌开始，对每个点数的牌集合进行穷举，枚举所有可能的组合。
3. 对于每个组合，判断它是否合法，即是否是三张及以上同点数不同花色的牌组或者三张及以上的同花顺。
4. 如果组合合法，计算它的点数累加值，并将它加入到一个列表中。
5. 对于每个点数的牌集合，枚举完所有可能的组合后，选取点数累加值最大的组合，将它加入到最终的组合列表中。
6. 对于所有点数的牌集合，重复步骤2~5，直到找到所有可能的组合。

下面是一个Python实现的例子（假设牌已经被转换成了一个包含点数和花色的元组的列表cards）：

def find_combinations(cards):
    # 将牌按点数分类
    card_dict = {}
    for card in cards:
        if card[0] not in card_dict:
            card_dict[card[0]] = [card]
        else:
            card_dict[card[0]].append(card)

    # 递归查找所有可能的组合
    def backtrack(curr_cards, curr_sum, curr_combination):
        nonlocal max_sum, max_combinations
        if len(curr_cards) == 0:
            if curr_sum > max_sum:
                max_sum = curr_sum
                max_combinations = curr_combination
            return

        point, cards = curr_cards[0]
        for i in range(1, len(cards) + 1):
            combination = cards[:i]
            if is_valid_combination(combination):
                new_sum = curr_sum + point * i
                new_combination = curr_combination + combination
                backtrack(curr_cards[1:], new_sum, new_combination)

    # 判断组合是否合法
    def is_valid_combination(combination):
        if len(combination) < 3:
            return False
        if is_same_suit(combination):
            return is_straight_flush(combination)
        else:
            return is_same_rank(combination)

    def is_same_suit(combination):
        return len(set(card[1] for card in combination)) == 1

    def is_same_rank(combination):
        return len(set(card[0] for card in combination)) == 1

    def is_straight_flush(combination):
        ranks = sorted(card[0] for card in combination)
        return all(ranks[i+1] == ranks[i] + 1 for i in range(len(ranks) - 1))

    # 初始化变量并开始查找
    max_sum = 0
    max_combinations = []
    backtrack(list(card_dict.items()), 0, [])

    return max_combinations

这个函数的时间复杂度是O(2^20)，即最坏情况下需要穷举所有20张牌的可能组合。实际上，由于存在一些剪枝（例如，当已经找到的组合的点数加上剩余牌的点数小于已知的最大点数时，可以直接返回），实际运行时间应该远远小于这个上界。