递归回溯-python。 不返回价值

Question

问题

我知道在函数的某个地方，我没有返回应有的东西。

我正在返回递归调用，但似乎没有返回“全部”

语境

我正在对列表中的每个单个组合进行深度优先搜索。 一旦达到条件的组合，我想返回。

我正在维持合并的“状态”，并回溯到应该的位置（我认为）。

我究竟做错了什么？

class Combo:
    def __init__(self, list):
       self.staples = list

组合具有名为“装订”的属性，其中包括装订类别的列表。 我想遍历决策树中的订书钉列表以找到最佳数量。

在这种情况下，最佳数量将在列表中每个订书钉实例的数量上相加，并作为组合实例上的属性进行存储/重新计算。

def IterateStaples(combo, target):        
  #Exit condition for combo dictionary
  if all(combo.diff[macro] < 2 for macro in combo.diff):    
    return combo;                            

  #iterate through all items in list
  for staple in combo.staples:                                  

    #Increment and calc conditions
    staple.increment()         
    combo.calcTotals()      
    combo.findDiff(target)

    #If exceeds target value, backtrack
    if combo.findConflict(target):                
      staple.decrement()
      combo.calcTotals()                
      combo.findDiff(target)              

    #Redundant exit condition to try and return
    elif all(combo.diff[macro] < 2 for macro in combo.diff):                                  
      return combo                

    #Recursive call
    else:        
      return IterateStaples(combo, target)
      staple.decrement()
      combo.calcTotals()
      combo.findDiff(target)

Answer 1

for循环内的第一个if语句不返回任何内容。 它应返回的内容取决于算法的逻辑：

#If exceeds target value, backtrack
if combo.findConflict(target):                
   staple.decrement()
   combo.calcTotals()                
   combo.findDiff(target)
   return SOMETHING

此外，最近3线永远不会得到执行，他们是后 return的语句。

Answer 2

如果我正确地理解了您的代码（这比平时更困难，因为您没有显示要在combo和staple上调用的大多数方法是什么），那么这应该是您想要的：

def IterateStaples(combo, target):        
    # base case
    if all(combo.diff[macro] < 2 for macro in combo.diff): # iterate on combo.diff.values()?
        return combo   # returning combo indicates success!

    for staple in combo.staples:
        staple.increment()                 # update state   
        combo.calcTotals()      
        combo.findDiff(target)

        if not combo.findConflict(target):  # skip recursing on invalid states
            result = IterateStaples(combo, target)    # recursive case
            if result is not None:      # if the recursion was successful, return the result
                return result

        staple.decrement()  # otherwise, undo the change to the state (backtrack)
        combo.calcTotals()     # these two lines might not be necessary when backtracking
        combo.findDiff(target) # since other branches will call them after staple.increment()

    return None # if we got to the end of the loop, explicitly return None to signal failure

最后没有严格要求return None ，因为如果您不返回其他任何内容，则None是默认的返回值。 我只是认为最好将其明确。

我正在遵循您的代码，如果成功则返回combo （并将失败时扩展为返回None ）。 由于代码会原地改变combo ，因此您也可以返回True表示成功（在函数的顶部是基本情况），而False表示失败（在循环结束后在函数的底部）。 递归逻辑将传递True结果，并在False结果之后回溯。 如果顶级调用者获得了True返回值，则需要检查传入的combo实例以获取实际的解决方案：

combo = Combo(something)
if IterateStaples(combo, target):
    do_stuff(combo) # success!

Answer 3

通过在下面合并一个辅助函数，我能够通过自己的测试用例：

这不是回溯吗？ 我用类似的方法实现了N皇后

def IterateStaples(combo, target):        
  #iterate through all items in list
  bestCombo = []
  def helper(combo):
    for staple in combo.staples:                                      
      #Increment and calc conditions
      staple.increment()         
      combo.calcTotals()      
      combo.findDiff(target)    

      #If exceeds target value, backtrack
      if combo.findConflict(target):                      
        staple.decrement()
        combo.calcTotals()                
        combo.findDiff(target)                                        

      #Redundant exit condition to try and return
      elif all(combo.diff[macro] < 2 for macro in combo.diff):                                          
        bestCombo.append(deepcopy(combo))        
        return                

      #Recursive call
      else:        
        helper(combo)
        staple.decrement()
        combo.calcTotals()
        combo.findDiff(target)

  helper(combo)  

  return bestCombo