力扣 1373. 二叉搜索子树的最大键值和

题目

给你一棵以 root 为根的 二叉树 ，请你返回 任意 二叉搜索子树的最大键值和。
二叉搜索树的定义如下：

任意节点的左子树中的键值都 小于 此节点的键值。
任意节点的右子树中的键值都 大于 此节点的键值。
任意节点的左子树和右子树都是二叉搜索树。

示例

输入：root = [1,4,3,2,4,2,5,null,null,null,null,null,null,4,6]
输出：20
解释：键值为 3 的子树是和最大的二叉搜索树。

输入：root = [4,3,null,1,2]
输出：2
解释：键值为 2 的单节点子树是和最大的二叉搜索树。

输入：root = [-4,-2,-5]
输出：0
解释：所有节点键值都为负数，和最大的二叉搜索树为空。

输入：root = [2,1,3]
输出：6
：

输入：root = [5,4,8,3,null,6,3]
输出：7

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-sum-bst-in-binary-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

想法

后序遍历+递归过程完成数组计数减少多次递归。

实现

方法1：java

class Solution {
    // 全局变量最大键值
    public int resMax = 0;

    public int maxSumBST(TreeNode root) {
        getMax(root);
        
        return resMax;
    }

    /*
    * 输入：传入结点
    * return：四位整型数组
    * res[0]记录以root为根的二叉树是否是 BST，若为 1 则说明是 BST，若为 0 则说明不是 BST；
    * res[1]记录以root为根的二叉树所有节点中的最小值；
    * res[2]记录以root为根的二叉树所有节点中的最大值；
    * res[3]记录以root为根的二叉树所有节点值之和。
     */
    public int[] getMax(TreeNode root) {
        if (root == null) {
            return new int[] {1, Integer.MAX_VALUE, Integer.MIN_VALUE, 0};
        }

        // 递归计算左右子树
        int[] left = getMax(root.left);
        int[] right = getMax(root.right);

        int[] res = new int[4];
        // 左右子树都是 BST且左子树的最大值小于当前结点，右子树的最小值大于当前节点
        if (left[0] == 1 && right[0] == 1 && left[2] < root.val && right[1] > root.val) {
            // 当前结点是 BST
            res[0] = 1;
            // 获取以当前结点为根的 BST的最小值
            res[1] = Math.min(left[1], root.val);
            // 获取以当前结点为根的 BST的最大值
            res[2] = Math.max(right[2], root.val);
            // 获取以当前结点为根的 BST的所有结点之和
            res[3] = left[3] + right[3] + root.val;
            // 更新全局变量
            resMax = Math.max(resMax, res[3]);
        } else {
            res[0] = 0;
        }

        return res;
    }
}

方法2：python
第一种方法的变种，没啥区别。

python中对应java中生成最大最小的：

JAVA：
Integer.MAX_VALUE
Integer.MIN_VALUE

python：
float(‘inf’)
float(’-inf’)

class Solution:
    def maxSumBST(self, root: TreeNode) -> int:
        def traverse(root):
            if not root: 
                return float('inf'),float('-inf'),0
            
            lmin,lmax,lsum=traverse(root.left)
            rmin,rmax,rsum=traverse(root.right)

            if  rmin>root.val>lmax:
                nonlocal maxsum
                maxsum=max(maxsum,lsum+rsum+root.val)
                return min(lmin,root.val),max(rmax,root.val),lsum+rsum+root.val
            return float('-inf'),float('inf'),0
        maxsum=0
        traverse(root)
        return maxsum