leetcode二叉树 找路径_LeetCode-124 二叉树中的最大路径和

题目：给定一个非空二叉树，返回其最大路径和。

本题中，路径被定义为一条从树中任意节点出发，达到任意节点的序列。该路径至少包含一个节点，且不一定
经过根节点。

解法一：递归法（双层递归）

首先说下，递归法的思路特别简单，但正因为思路简单，时间复杂度会相应高一点。如下程序，6行代码可以搞定，但会超时，后面说如何优化。

然后说下思路：

1. 用第一层递归，找到以树种每个节点为根节点，向下路径中的最大和，这个路径不一定是从根节点到叶节点，只找路径中出现的最大和即可，用node.maxP表示，>0表示正增益，<0表示负增益；
2. 根据本题定义的最大路径和，以树中每个节点为根节点root，加上root.left、root.right中的正增益（步骤1中求出），即为经过该root节点的最大路径和；
3. 用第二层递归，遍历树中所有节点的步骤2中的最大路径和，不断返回最大值，最终得到全局最大路径和。

代码如下：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
import sys
class Solution:
    def maxPathSum(self, root: TreeNode) -> int:
        if not root:return -sys.maxsize-1

        #步骤1，求以node节点为根节点的子树的最大路径和
        def maxPath(node):
            if not node:
                return -sys.maxsize-1
            
            return max(node.val + max(maxPath(node.left), maxPath(node.right)), node.val)
        #步骤2，比较当前节点与其左、右节点的最大路径和，返回最大值
        return max(root.val, root.val + maxPath(root.left), root.val + maxPath(root.right), root.val + maxPath(root.left) + maxPath(root.right), self.maxPathSum(root.left), self.maxPathSum(root.right))

以上代码遇到大规模树时会超时，原因很容易发现：就是在第二层递归中，每一层递归都会调用第一层递归，这样深度优先遍历树时，会存在大量对步骤1的重复调用。（联想之前的DP规划top → down遍历时，也会有问题）

解决方法就是和DP规划相同的方法：记忆表，如果只需要调用一次步骤1，然后将每个节点的最大路径和对应存储起来，这样在第二层递归中就可以直接使用，不需要再重新递归计算。

那如何存储每个节点的最大路径和呢？因为这里是树结构，不像之前的数组，所以存储起来会有困难。这里我采用了116-117题中的一个方法，就是给树中每个节点增加一个属性node.maxP来存储其最大路径。

这里很奇妙的是，我发现并不需要在初始化中增加树的节点属性，可以直接使用。原因在于python中类的属性，可以不用声明，在赋值时直接生效，像局部变量一样。详细见如下两个解释：解释1、解释2

看代码：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
import sys
class Solution:
    
    #求以node节点为根节点的子树的最大路径和
    def maxPath(self, node:TreeNode) -> int:
            if not node:
                return -sys.maxsize-1
            
            node.maxP = max(node.val + max(self.maxPath(node.left), self.maxPath(node.right)), node.val)
            return node.maxP

    def maxPathSum(self, root: TreeNode) -> int:
        if not root:return -sys.maxsize-1
        #调用一次步骤1，求出并存储所有节点的最大路径和
        self.maxPath(root)
        
        #第二次递归，求每个几点为根节点的最大路径和（题目所定义的），返回最大值
        def digui(node):
            if not node:
                return -sys.maxsize-1

            if not node.left and not node.right:
                return node.maxP
            #此时比较最大值时，要弄清楚node.maxP的含义，否
            #则会写出这样的表达式return max(node.val, node.val+node.right.maxP, digui(node.right))，虽然也没错，但会重复比较
            elif not node.left:
                return max(node.maxP, digui(node.right))
            elif not node.right:
                return max(node.maxP, digui(node.left))
            else:
                return max(node.maxP, node.val + node.left.maxP + node.right.maxP, digui(node.left), digui(node.right))
        
        return digui(root)

执行结果：通过显示详情
执行用时 :100 ms, 在所有 python3 提交中击败了78.70%的用户
内存消耗 :20.2 MB, 在所有 python3 提交中击败了100.00%的用户

写法二：递归

看了两个比较简练的写法，总体思路和他们是一样的，不过在保存最大值的方式、递归的写法不一样。

题解中使用全局变量，在递归中就考虑包含当前节点的最大路径和，然后不断更新最大路径和（解法一中步骤2的路径和），而递归返回的确是子树的增益（对应解法一中的步骤1）。

def maxPathSum(self, root: TreeNode) -> int:
        self.res = float("-inf")
        def helper(root):
            if not root: return 0
            # 右边最大值
            left = helper(root.left)
            # 左边最大值
            right = helper(root.right)
            # 和全局变量比较
            self.res = max(left + right + root.val, self.res)
            # >0 说明都能使路径变大
            return max(0, max(left,  right) + root.val)
        helper(root)
        return self.res 

作者：powcai
链接：https://leetcode-cn.com/problems/binary-tree-maximum-path-sum/solution/quan-ju-bian-liang-by-powcai/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

代码的解释可以参考这里