如何在 Python 中递归期间使用共享变量

我正在实现基于回溯的递归解决方案，并希望根据条件更新变量 min_path。 如果我在递归 function 之外定义变量，我会得到一个参考错误，实现这种解决方案的最佳方法是什么

class Solution:
def minPathSum(self, grid: List[List[int]]) -> int:
    if not grid:
        return


    R = len(grid)
    C = len(grid[0])
    min_path = None

    def backtrack(grid, i, j, current_path):

        if i >= R or j>= C:
            return
        current_path += grid[i][j]
        if i == R-1 and j == C-1:
            if not min_path:
                min_path = current_path
            else:
                min_path = min(min_path, current_path)
            print(min_path)
            return
        backtrack(grid, i, j+1, current_path)
        backtrack(grid, i+1, j, current_path)

    backtrack(grid, 0, 0,0)

    return min_path

作为参考，这是我要解决的问题： https://leetcode.com/problems/minimum-path-sum/

您的变量 min_path 的范围仅限于 main 方法，并且不适用于作为 class object 成员的函数。 为了在回溯方法中引用它，您要么需要

1. 将 min_path 定义为 backtrack 方法中的局部变量（这可能会导致其他问题，因为您正在递归调用它）：

class Solution:
def minPathSum(self, grid: List[List[int]]) -> int:
    if not grid:
        return

    R = len(grid)
    C = len(grid)
    min_path_main = None

    min_path_main = backtrack(grid, 0, 0,0)

    return min_path_main

  def backtrack(grid, i, j, current_path):
    min_path = None
    if i >= R or j>= C:
        break
      current_path += grid[i][j]
      if i == R-1 and j == C-1:
        if not min_path:
            min_path = current_path
        else:
            min_path = min(min_path, current_path)
            print(min_path)
            break
    # it's possible you'll need extra logic here to manage the output. 
    output1 = backtrack(grid, i, j+1, current_path)
    output2 = backtrack(grid, i+1, j, current_path)

  return min_path

2. 将变量定义为 class 变量：

class Solution:
def __init__(self):
  self.min_path = None

def minPathSum(self, grid: List[List[int]]) -> int:
    if not grid:
        return

    R = len(grid)
    C = len(grid)

    backtrack(grid, 0, 0,0)

    return self.min_path

def backtrack(grid, i, j, current_path):
    if i >= R or j>= C:
        break
      current_path += grid[i][j]
      if i == R-1 and j == C-1:
        if not self.min_path:
            self.min_path = current_path
        else:
            self.min_path = min(self.min_path, current_path)
            print(self.min_path)
            break
    backtrack(grid, i, j+1, current_path)
    backtrack(grid, i+1, j, current_path)

  return

可能需要玩一点。 我没有输入数据，所以我没有运行代码。 但这些是您实施我提供的解决方案的方式。

由于目标是简单地找到最小和，因此无需跟踪路径的坐标。 您可以从您正在采取的步骤的角度使用网格的剩余部分进行递归调用：

def min_sum(g):
    if not g or not g[0]:
        return float('inf')
    return g[0][0] + ((len(g) > 1 or len(g[0]) > 1) and min(map(min_sum, (g[1:], [*zip(*g)][1:]))))

以便：

min_sum([
  [1,3,1],
  [1,5,1],
  [4,2,1]
])

返回： 7