leetcode分类刷题：二叉树（四、与路径相关的递归）

与路径相关的递归问题通常是在前序遍历和层序遍历上稍加改动，将入栈或入队的元素调整为多元组的形式，将路径记录、路径之和等同时保存上

257. 二叉树的所有路径

思路：遍历时记录路径节点，采用前序或层序遍历都可以
写法1、前序遍历递归写法：重复逻辑：对每个二叉树依次执行当前节点路径更新、访问左右子树的操作
写法2、前序遍历迭代写法：入栈的是二元组(节点，路径记录)；换作层序遍历迭代时，入队的是二元组(节点，路径记录)

'''
257. 二叉树的所有路径
给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。
叶子节点 是指没有子节点的节点。
示例 1:
    输入：root = [1,2,3,null,5]
    输出：["1->2->5","1->3"]
思路：遍历时记录路径节点，采用前序或层序遍历都可以
写法1、前序遍历递归写法：重复逻辑：对每个二叉树依次执行当前节点路径更新、访问左右子树的操作
写法2、前序遍历迭代写法：入栈的是二元组(节点，路径记录)；换作层序遍历迭代时，入队的是二元组(节点，路径记录)
'''
class Solution:
    # 写法1、前序遍历递归写法：重复逻辑：对每个二叉树依次执行当前节点路径更新、访问左右子树的操作
    def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        result = []
        def traversal(root: Optional[TreeNode], path: str):
            # 简单情况
            if root == None:
                return
            elif root.left == None and root.right == None:
                result.append(path + str(root.val))
            else:  # 重复逻辑
                path = path + str(root.val) + '->'
                traversal(root.left, path)
                traversal(root.right, path)
        traversal(root, '')
        return result

    # 写法2、前序遍历迭代写法：入栈的是带有路径记录的节点
    def binaryTreePathsIteration(self, root: Optional[TreeNode]) -> List[str]:
        if root == None:
            return []
        result = []
        stkNodePath = [(root, str(root.val))]  # 二元组(节点，路径记录)入栈
        while len(stkNodePath) > 0:
            cur, path = stkNodePath.pop()
            if cur.left == None and cur.right == None:
                result.append(path)
            if cur.right:    # 先右后左入栈， 先左后右出栈
                stkNodePath.append((cur.right, path+'->'+str(cur.right.val)))
            if cur.left:
                stkNodePath.append((cur.left, path + '->' + str(cur.left.val)))
        return result

112. 路径总和

思路：遍历时记录路径节点，采用前序或层序遍历都可以，这种题目更适合采用迭代循环遍历实现
前序遍历迭代写法：入栈的是二元组(节点，路径之和)；换作层序遍历迭代时，入队的是二元组(节点，路径之和)

'''
112. 路径总和
给你二叉树的根节点root 和一个表示目标和的整数targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和targetSum 。
如果存在，返回 true ；否则，返回 false 。叶子节点 是指没有子节点的节点。
示例 1:
    输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
    输出：true
    解释：等于目标和的根节点到叶节点路径如上图所示。
思路：遍历时记录路径节点，采用前序或层序遍历都可以，这种题目更适合采用迭代循环遍历实现
前序遍历迭代写法：入栈的是二元组(节点，路径之和)；换作层序遍历迭代时，入队的是二元组(节点，路径之和)
'''
class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        if root == None:
            return False
        stkNodeSum = [(root, root.val)]  # # 二元组(节点，路径之和)入栈
        while len(stkNodeSum) > 0:
            cur, pathSum = stkNodeSum.pop()
            if cur.left == None and cur.right == None:
                if pathSum == targetSum:
                    return True
            if cur.right:    # 先右后左入栈， 先左后右出栈
                stkNodeSum.append((cur.right, pathSum + cur.right.val))
            if cur.left:
                stkNodeSum.append((cur.left, pathSum + cur.left.val))
        return False

113. 路径总和 II

思路：遍历时记录路径节点，采用前序或层序遍历都可以，这种题目更适合采用迭代循环遍历实现
前序遍历迭代写法：入栈的是三元组(节点，路径之和，路径记录)；换作层序遍历迭代时，入队的是三元组(节点，路径之和，路径记录)

'''
113. 路径总和 II
给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。
叶子节点 是指没有子节点的节点。
示例 1:
    输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
    输出：[[5,4,11,2],[5,8,4,5]]
思路：遍历时记录路径节点，采用前序或层序遍历都可以，这种题目更适合采用迭代循环遍历实现
前序遍历迭代写法：入栈的是三元组(节点，路径之和，路径记录)；换作层序遍历迭代时，入队的是三元组(节点，路径之和，路径记录)
'''
class Solution:
    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
        if root == None:
            return []
        result = []
        stkNodeAddPath = [(root, root.val, [root.val])]
        while len(stkNodeAddPath) > 0:
            cur, add, path = stkNodeAddPath.pop()
            if cur.left == None and cur.right == None:
                if add == targetSum:
                    result.append(path)
            if cur.right:    # 先右后左入栈， 先左后右出栈
                stkNodeAddPath.append((cur.right, add + cur.right.val, path + [cur.right.val]))  # + 的精髓
            if cur.left:
                stkNodeAddPath.append((cur.left, add + cur.left.val, path + [cur.left.val]))  # + 的精髓
        return result

437. 路径总和 III

思路1、遍历时记录路径节点，采用前序或层序遍历都可以，这种题目更适合采用迭代循环遍历实现；前序遍历迭代：入栈的是二元组(节点，路径之和)，注意此时的路径之和指的是以该节点为终点的所有的路径之和
思路2、前缀和优化的方法，前序遍历迭代：入栈的是三元组(节点，前缀和，前缀和哈希表)，注意前缀和哈希表需要调用copy()拷贝副本
思路3、将思路2修改为递归写法，注意最后一行代码：当我们退出当前节点时，我们需要及时退掉已经保存的前缀和；重复逻辑：对每个二叉树根节点进行前缀和统计答案、访问左右子树、退掉当前根节点前缀和的操作

'''
437. 路径总和 III
给定一个二叉树的根节点 root ，和一个整数 targetSum ，求该二叉树里节点值之和等于 targetSum 的 路径 的数目。
路径 不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。
示例 1:
    输入：root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8
    输出：3
思路1、遍历时记录路径节点，采用前序或层序遍历都可以，这种题目更适合采用迭代循环遍历实现；前序遍历迭代：入栈的是二元组(节点，路径之和)，注意此时的路径之
和指的是以该节点为终点的所有的路径之和
思路2、前缀和优化的方法，前序遍历迭代：入栈的是三元组(节点，前缀和，前缀和哈希表)，注意前缀和哈希表需要调用copy()拷贝副本
思路3、将思路2修改为递归写法，注意最后一行代码：当我们退出当前节点时，我们需要及时退掉已经保存的前缀和；
重复逻辑：对每个二叉树根节点进行前缀和统计答案、访问左右子树、退掉当前根节点前缀和的操作
'''
class Solution:
    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> int:
        if root == None:
            return 0
        result = 0
        stkNodeAdds = [(root, [root.val])]
        while len(stkNodeAdds) > 0:
            cur, adds = stkNodeAdds.pop()
            for add in adds:
                if add == targetSum:
                    result += 1
            # 先右后左入栈， 先左后右出栈
            if cur.right:
                temp = []
                for add in adds:  # 每次增加一个新的节点，都要把以该节点为终点的所有路径之和添加一遍
                    temp.append(add + cur.right.val)
                stkNodeAdds.append((cur.right, temp + [cur.right.val]))  # 也要把该节点为终点同时也为起点的路径之和添加一下
                # 仔细思考一下：这里的路径之和不能用集合，只能用列表，集合会自动去重，可能会使统计的符合条件的路径数少了
            if cur.left:
                temp = []
                for add in adds:
                    temp.append(add + cur.left.val)
                stkNodeAdds.append((cur.left, temp + [cur.left.val]))
        return result

    def pathSum2(self, root: Optional[TreeNode], targetSum: int) -> int:
        if root == None:
            return 0
        result = 0
        hashTable = {0: 1}  # 这里保证了对 包含起始节点的路径之和 的判断
        prefixSum = 0
        stkNodeAdds = [(root, prefixSum, hashTable)]
        while len(stkNodeAdds) > 0:
            cur, prefixSum, hashTable = stkNodeAdds.pop()
            prefixSum += cur.val
            # 1、先找 以当前遍历元素n对应的索引位置 之前的前缀和是否存在满足条件的
            if prefixSum - targetSum in hashTable:
                result += hashTable[prefixSum - targetSum]
            # 2、再将当前遍历节点为终点的路径之和 的前缀和添加到hashDict
            if prefixSum not in hashTable:
                hashTable[prefixSum] = 1
            else:
                hashTable[prefixSum] += 1
            # 先右后左入栈， 先左后右出栈
            if cur.right:
                stkNodeAdds.append((cur.right, prefixSum, hashTable.copy()))  # 这里需要调用.copy()方法
            if cur.left:
                stkNodeAdds.append((cur.left, prefixSum, hashTable.copy()))
        return result

    def pathSum3(self, root: TreeNode, targetSum: int) -> int:
        hashTable = {0: 1}  # 设置全局形式的哈希表；直接带到函数中调用也可实现这个效果，因为dict是python中的可变变量，相当于全局变量

        def dfs(root, prefixSum):
            # 简单情况
            if not root:
                return 0
            # 重复逻辑：对每个二叉树根节点进行前缀和统计答案、访问左右子树、退掉当前根节点前缀和的操作
            result = 0
            prefixSum += root.val
            # 1、先找 以当前遍历元素n对应的索引位置 之前的前缀和是否存在满足条件的
            if prefixSum - targetSum in hashTable:
                result += hashTable[prefixSum - targetSum]
            # 2、再将当前遍历节点为终点的路径之和 的前缀和添加到hashDict
            if prefixSum not in hashTable:
                hashTable[prefixSum] = 1
            else:
                hashTable[prefixSum] += 1
            result += dfs(root.left, prefixSum)
            result += dfs(root.right, prefixSum)
            hashTable[prefixSum] -= 1  # 当我们退出当前节点时，我们需要及时退掉已经保存的前缀和
            return result

        return dfs(root, 0)