Python：递归函数。如何返回targetsum的所有子集

我的代码没有显示最短的子集，例如[7]，或者它没有读取所有的子集[7]，[3,4]，以返回最短的子集。可以解释为什么只有一组结果是返回的，我应该如何修改它以显示所有子集？谢谢

下面是我想要遵循的代码的图片

def howsum（targetsum，number，combo=None）：
如果combo==无：
combo=list（）
如果targetsum==0：返回[]
如果targetsum<0：返回无
shortcombo=无
对于数字中的数字：
余数=targetsum-数字
combo=howsum（余数、数字、组合）
如果组合！=无：
combo.append（数字）
如果shortcombo==无或len（shortcombo）>len（组合）：
shortcombo=组合
返回短波
返回短波
打印（豪森（7[4,3,7]））

我对此不确定，但在python中定义一个函数并给出两组代码时，调用该函数时实际上并没有执行第二组代码。我在其他项目中遇到了同样的问题。我没有得到答案，只是说我在代码中犯了一些错误

我对此不确定，但在python中定义一个函数并给出两组代码时，调用该函数时实际上并没有执行第二组代码。我在其他项目中遇到了同样的问题。我没有得到答案，只是说我在代码中犯了一些错误

我签出了你的代码。我觉得缺少的是

• 返回的位置不正确，并且将值存储在combo（集合）中 而不是列表）

  def howsum（targetsum，number，combo=None）：
  如果combo==无：
  combo=set（）
  如果targetsum==0：
  返回[]
  如果targetsum<0：
  一无所获
  对于idx，枚举中的数字（数字）：
  余数=targetsum-数字
  如果howsum（余数，数字[idx:]，组合）！=无：
  组合。添加（数字）
  其他：
  返回组合
  一无所获
  

print（howsum（7[7,3,4,2,5]））

---

希望这有帮助。虽然这为您提供了一个解决方案，但我建议您使用不同的方法来解决此类问题（两个和解决方案）或使用O（n）的双指针方法。

我检查了您的代码。我觉得缺少的是

• 返回的位置不正确，并且将值存储在combo（集合）中 而不是列表）

  def howsum（targetsum，number，combo=None）：
  如果combo==无：
  combo=set（）
  如果targetsum==0：
  返回[]
  如果targetsum<0：
  一无所获
  对于idx，枚举中的数字（数字）：
  余数=targetsum-数字
  如果howsum（余数，数字[idx:]，组合）！=无：
  组合。添加（数字）
  其他：
  返回组合
  一无所获
  

print（howsum（7[7,3,4,2,5]））

---

希望这有帮助。虽然这为您提供了一个解决方案，但我建议您使用不同的方法来解决此类问题（两个和解决方案）或使用O（n）的双指针方法。

添加了记忆，但是在num集合中使用1。结果失控

def best_sum(target_sum, numbers,memo=None):
    if memo == None:
      memo = dict()
    
    if target_sum in memo:
      return memo[target_sum]
  
    if target_sum == 0: return []
    if target_sum < 0: return None
    
    shortest_combination = None

    for num in numbers:
        remainder = target_sum - num
        remainder_combination = best_sum(remainder, numbers,memo)
        if remainder_combination != None:
            remainder_combination.append(num)
            combination = remainder_combination
            if shortest_combination == None or len(combination) < len(shortest_combination):
                shortest_combination = combination
    memo[target_sum] = shortest_combination
    return shortest_combination

print(best_sum(100,[5,1,25]))

---

增加了记忆，但是里面有1组num。结果乱七八糟

def best_sum(target_sum, numbers,memo=None):
    if memo == None:
      memo = dict()
    
    if target_sum in memo:
      return memo[target_sum]
  
    if target_sum == 0: return []
    if target_sum < 0: return None
    
    shortest_combination = None

    for num in numbers:
        remainder = target_sum - num
        remainder_combination = best_sum(remainder, numbers,memo)
        if remainder_combination != None:
            remainder_combination.append(num)
            combination = remainder_combination
            if shortest_combination == None or len(combination) < len(shortest_combination):
                shortest_combination = combination
    memo[target_sum] = shortest_combination
    return shortest_combination

print(best_sum(100,[5,1,25]))

---

编写的代码与原始JavaScript非常匹配

虽然JavaScript名称可以使用，但我对函数和变量名称进行了重构，以获得一致，即：

• 函数名应该是小写的，并根据需要用下划线分隔单词，以提高可读性
• 变量名遵循与函数名相同的约定

代码

def best_sum(target_sum, numbers):
    if target_sum == 0: return []
    if target_sum < 0: return None
    
    shortest_combination = None

    for num in numbers:
        remainder = target_sum - num
        remainder_combination = best_sum(remainder, numbers)
        if remainder_combination != None:
            combination = [*remainder_combination, num] # Python * equivalent to JavaSscript ...
            if shortest_combination == None or len(combination) < len(shortest_combination):
                shortest_combination = combination
    
    return shortest_combination

使用记忆（即缓存）

def最佳总和（目标总和、数字、备忘录=无）：
如果备忘录为无：
备忘录={0:[]}
如果目标_和<0：
一无所获
如果目标金额在备忘录中：
返回备忘录[目标金额]
最短组合=无
对于数字中的num：
余数=目标总和-数值
余数组合=最佳总和（余数、数字、备忘录）
如果余数_组合！=无：
组合=[*余数_组合，num]#Python*相当于JavaSscript。。。
如果最短组合==无或len（组合）

编写的代码与原始JavaScript非常匹配

虽然JavaScript名称可以使用，但我对函数和变量名称进行了重构，以获得一致，即：

• 函数名应该是小写的，并根据需要用下划线分隔单词，以提高可读性
• 变量名遵循与函数名相同的约定

代码

def best_sum(target_sum, numbers):
    if target_sum == 0: return []
    if target_sum < 0: return None
    
    shortest_combination = None

    for num in numbers:
        remainder = target_sum - num
        remainder_combination = best_sum(remainder, numbers)
        if remainder_combination != None:
            combination = [*remainder_combination, num] # Python * equivalent to JavaSscript ...
            if shortest_combination == None or len(combination) < len(shortest_combination):
                shortest_combination = combination
    
    return shortest_combination

使用记忆（即缓存）

def最佳总和（目标总和、数字、备忘录=无）：
如果备忘录为无：
备忘录={0:[]}
如果目标_和<0：
一无所获
如果目标金额在备忘录中：
返回备忘录[目标金额]
最短组合=无
对于数字中的num：
余数=目标总和-数值
余数组合=最佳总和（余数、数字、备忘录）
如果余数_组合！=无：
组合=[*余数_组合，num]#Python*相当于JavaSscript。。。
如果最短组合==无或len（组合）def best_sum(target_sum, numbers):
    if target_sum == 0: return []
    if target_sum < 0: return None
    
    shortest_combination = None

    for num in numbers:
        remainder = target_sum - num
        remainder_combination = best_sum(remainder, numbers)
        if remainder_combination != None:
            combination = [*remainder_combination, num] # Python * equivalent to JavaSscript ...
            if shortest_combination == None or len(combination) < len(shortest_combination):
                shortest_combination = combination
    
    return shortest_combination

print(bestSum(7, [3, 4, 7])) # Output: [7]

def best_sum(target_sum, numbers, memo = None):
    if memo is None:
        memo = {0:[]}
    if target_sum < 0:
        return None
    if target_sum in memo:
        return memo[target_sum]

    shortest_combination = None

    for num in numbers:
        remainder = target_sum - num

        remainder_combination = best_sum(remainder, numbers, memo)
        if remainder_combination != None:
            combination = [*remainder_combination, num] # Python * equivalent to JavaSscript ...
            if shortest_combination == None or len(combination) < len(shortest_combination):
                shortest_combination = combination

    memo[target_sum] = shortest_combination

    return memo[target_sum]

print(best_sum(7, [3, 4, 7]))  # Output: 7
# Following very slow on non-memoized version
print(best_sum(100,[10,1,25])) # Output: [25, 25, 25, 25]