如何在 Python 中遞歸期間使用共享變量

Question

我正在實現基於回溯的遞歸解決方案，並希望根據條件更新變量 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/

Answer 1

您的變量 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

可能需要玩一點。 我沒有輸入數據，所以我沒有運行代碼。 但這些是您實施我提供的解決方案的方式。

Answer 2

由於目標是簡單地找到最小和，因此無需跟蹤路徑的坐標。 您可以從您正在采取的步驟的角度使用網格的剩余部分進行遞歸調用：

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