PYTHON：使用递归从具有条件的列表中查找所有组合

Question

我有一份物品清单，包括价格和所需数量。

[ [ “神圣铸造厂”, 12.69, 2 ], [ “血污泥潭”, 26.55, 2 ], [ “树木繁茂的山麓”, 25.97, 2 ], [ “翠绿的地下墓穴”, 14.54, 2 ], [ “愤怒”, 32.64, 4 ] ]

我想花一定的钱从那个列表中的项目中获得所有组合

如果我有 100 欧元，我可以买 3 个愤怒，或 2 个愤怒和一个树木繁茂的山麓和一个神圣的铸造厂......

    def find_combinations(items, target_sum, result_type='full'):
        items = sorted(items, key=lambda x: x[1], reverse=True)
        results = []
        closest_diff = float('inf')
        closest_combination = []
    
        def backtrack(start, target_sum, combination):
            nonlocal closest_diff
            nonlocal closest_combination
    
            if target_sum < 0:
                return
            if target_sum == 0:
                results.append(combination)
                return
            if start == len(items):
                return
    
            for i in range(start, len(items)):
                for j in range(1, items[i][2] + 1):
                    if target_sum - items[i][1] * j >= 0:
                        backtrack(i + 1, target_sum - items[i][1] * j, combination + [(items[i][0], j)])
                    if abs(target_sum - items[i][1] * j) < closest_diff:
                        closest_diff = abs(target_sum - items[i][1] * j)
                        closest_combination = combination + [(items[i][0], j)]
    
        backtrack(0, target_sum, [])
        if len(results) > 0:
            results = [results[0]]
        elif len(closest_combination) > 0:
            results = [closest_combination]
        else:
            return []
    
        if result_type == 'full':
            return results
        elif result_type == 'most_items':
            return [max(results, key=lambda x: sum(map(lambda y: y[1], x)))]
        elif result_type == 'most_expensive':
            return [max(results, key=lambda x: sum(map(lambda y: y[0][1] * y[1], x)))]
        else:
            return results

它在不同网站和 chatgpt 的帮助下尝试了这个，但它似乎只返回一个结果。

谢谢

Answer 1

这段代码有一些问题。

首先，这部分代码：

 if len(results) > 0:
     results = [results[0]]
 elif len(closest_combination) > 0:
     results = [closest_combination]
 else:
     return []

得到第一个结果。 因此它不会为您打印所有结果。

其次，在您的回溯 function 中，当没有新项目可以添加到列表中时，它不会 append 它已经具有的组合。 您可以像这样使用 boolean 修复这部分代码：

can_add_new_one = False
for i in range(start, len(items)):
        for j in range(1, items[i][2] + 1):
            if target_sum - items[i][1] * j >= 0:
                can_add_new_one = True
                backtrack(i + 1, target_sum - items[i][1] * j, combination + [(items[i][0], j)])
            if abs(target_sum - items[i][1] * j) < closest_diff:
                closest_diff = abs(target_sum - items[i][1] * j)
                closest_combination = combination + [(items[i][0], j)]
 if not can_add_new_one:
     results.append(combination)

此外，'most_expensive' 部分不起作用。 您可以将项目价格添加到结果列表中，以便能够计算出所有结果中最昂贵的结果。

这将解决代码的问题。 最终代码将是这样的：

def find_combinations(items, target_sum, result_type='full'):
    items = sorted(items, key=lambda x: x[1], reverse=True)
    results = []
    closest_diff = float('inf')
    closest_combination = []

    def backtrack(start, target_sum, combination):
        nonlocal closest_diff
        nonlocal closest_combination
        nonlocal results

        if target_sum < 0:
            return 
        if target_sum == 0:
            results.append(combination)
            return
        if start == len(items):
            return

        can_add_new_one = False
        for i in range(start, len(items)):
            for j in range(1, items[i][2] + 1):
                if target_sum - items[i][1] * j >= 0:
                    can_add_new_one = True
                    backtrack(i + 1, target_sum - items[i][1] * j, combination + [(items[i][0], j, items[i][1])])
                if abs(target_sum - items[i][1] * j) < closest_diff:
                    closest_diff = abs(target_sum - items[i][1] * j)
                    closest_combination = combination + [(items[i][0], j)]
        if not can_add_new_one:
            results.append(combination)
            

    backtrack(0, target_sum, [])

    if result_type == 'full':
        return results
    elif result_type == 'most_items':
        return [max(results, key=lambda x: sum(map(lambda y: y[1], x)))]
    elif result_type == 'most_expensive':
        return [max(results, key=lambda x: sum(map(lambda y: y[2] * y[1], x)))]
    else:
        return results