有没有更好的方法来退出递归？

Question

我有这个功能：

class Solution:
def __init__(self):
        self.flag = False


def hasPathSum(self, root: TreeNode, targetSum: int) -> bool:
    curr_sum = 0            

    
    def dfs(root, curr_sum, target_sum=targetSum):
        if self.flag == True:
            return True
        if root == None:
            return 0
        print(root.val)
        curr_sum += root.val
        print(curr_sum)
        if curr_sum == target_sum:
            self.flag = True
        dfs(root.left, curr_sum)
        dfs(root.right, curr_sum)
    dfs(root, curr_sum, targetSum)
    if self.flag == True:
        return True
    return False

当树的根到叶路径总和等于 target_sum 时，我想结束递归并获得 True。我设法通过添加 dunder 方法 init 并将那里的标志设置为 False 来做到这一点，当满足要求时我会切换它。 但在我看来，它感觉有点不干净也不漂亮。 我应该如何以更干净的方式做到这一点？

Answer 1

您根本不需要 Solution 类（强制所有内容都成为类是您在 Python 代码中不需要的 Java 主义），并且您的函数应该 return 它的值而不是坚持它在一个外部变量中。

递归函数的一般模式是：

• 检查基本情况，如果满足立即返回解决方案
• 否则，使用修改后的参数返回再次调用函数的结果，让您更接近基本情况。

def has_path_sum(self, root: TreeNode, target_sum: int) -> bool:
    """Returns whether any path through the tree 
    has values that sum to *exactly* target_sum."""
    def dfs(node: TreeNode, curr_sum: int) -> bool:
        """DFS helper that tracks sum of all nodes traversed."""
        # Base case: return False if we run out of nodes.
        if node is None:
            return False
        curr_sum += node.val
        return (
            # Base case: return True if we hit the target sum.
            curr_sum == target_sum
            # Otherwise, recurse into left and right subtrees.
            or dfs(node.left, curr_sum)
            or dfs(node.right, curr_sum)
        )

    return dfs(root, 0)

请注意在 DFS 帮助器的最后一部分中使用了 or —— or 一旦其任一子句为 True（按顺序），就会立即返回，因此：

        return (
            # Base case: return True if we hit the target sum.
            curr_sum == target_sum
            # Otherwise, recurse into left and right subtrees.
            or dfs(node.left, curr_sum)
            or dfs(node.right, curr_sum)
        )

只是一种更好/更短的说法：

        # Base case: return True if we hit the target sum.
        if curr_sum == target_sum:
            return  True
        # Otherwise, recurse into left and right subtrees.
        elif dfs(node.left, curr_sum):
            return True
        elif dfs(node.right, curr_sum):
            return True
        else:
            return False

Answer 2

如何使用方法参数来跟踪当前总和。

class TreeNode:
    def __init__(self, right, left, value):
        self.right = right
        self.left = left
        self.value = value


def solution(root: TreeNode, target_sum: int) -> bool:
    def _solution(node: TreeNode, running_sum: int) -> bool:
        if node is None:
            return False

        running_sum += root.value

        if target_sum == running_sum:
            return True
        return _solution(root.left, running_sum) or _solution(root.right, running_sum)
    
    return _solution(root, 0)

Answer 3

您可以让 dfs 函数返回当前总和是否达到。这是我正在谈论的一些示例代码：

def hasPathSum(self, root: TreeNode, targetSum: int) -> bool:
    curr_sum = 0            

    
    def dfs(root, curr_sum, target_sum=targetSum):
        if root == None:
            return 0
        print(root.val)
        curr_sum += root.val
        print(curr_sum)
        if curr_sum == target_sum:
            return = True
        return dfs(root.left, curr_sum) or dfs(root.right, curr_sum)
    return dfs(root, curr_sum, targetSum)