1373. Maximum Sum BST in Binary Tree

正常的思路解法，果然又超时了。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    // left node right, contain no negative values
    void func(TreeNode* root, vector<int>& vals){
        if (root==NULL){
            return;
        }
        func(root->left, vals);
        vals.push_back(root->val);
        func(root->right, vals);
    }
    // max sum; tree is BST
    void func2(TreeNode* root, int& sum, bool& isBST){
        vector<int> vals;
        func(root, vals);
        
        for(int i=0;i<vals.size();i++){
            sum += vals[i];
            if (i>=1&&vals[i-1]>=vals[i]){
                isBST = false;// not BST
                return;
            }
        }
        
    }
    
    
    
    int maxSumBST(TreeNode* root) {
        if (root==NULL){
            return 0;
        }
        
        int sum=0;
        int maxsum = 0;
        bool isBST=true;
        func2(root, sum, isBST);
        if (isBST){ // update maxsum
            maxsum = max(sum, maxsum);
        }
        
        int max1 = maxSumBST(root->left);
        int max2 = maxSumBST(root->right);
        maxsum = max(max1, maxsum);
        maxsum = max(max2, maxsum);
        
        return maxsum;
    }
};

增加了一点小技巧，如果树中所有值都是大于等于0的，且为BST，那么就可以不用比较其他子树了。54/55还差最后一个，还是超时了。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    // left node right, contain no negative values
    void func(TreeNode* root, vector<int>& vals){
        if (root==NULL){
            return;
        }
        func(root->left, vals);
        vals.push_back(root->val);
        func(root->right, vals);
    }
    // max sum; tree is BST
    void func2(TreeNode* root, int& sum, bool& isBST, bool& isMax){
        vector<int> vals;
        func(root, vals);
        
        for(int i=0;i<vals.size();i++){
            sum += vals[i];
            if (i>=1&&vals[i-1]>=vals[i]){
                isBST = false;// not BST
                return;
            }
            if (vals[i]<0){
                isMax = false;
            }
        }
    }
    
    
    
    int maxSumBST(TreeNode* root) {
        if (root==NULL){
            return 0;
        }
        
        int sum=0;
        int maxsum = 0;
        bool isBST=true;
        bool isMax=true;
        func2(root, sum, isBST, isMax);
        if (isBST){ // update maxsum
            maxsum = max(sum, maxsum);
            if (isMax){
                return maxsum;
            }
        }
        
        int max1 = maxSumBST(root->left);
        int max2 = maxSumBST(root->right);
        maxsum = max(max1, maxsum);
        maxsum = max(max2, maxsum);
        
        return maxsum;
    }
};

参考讨论里面的内容，因为我这种求和算法，都是从头到尾加起来的，所以比较慢；如果我们能存储中间结点的最大值，最小值，以及求和结果，会快很多，避免了重复操作。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    
    vector<int> travel(TreeNode* root, int& ans){
        if (root==NULL){
            return {50000, -50000, 0};
        }
        
        vector<int> leftnodes = travel(root->left, ans);
        vector<int> rightnodes = travel(root->right, ans);
        if (leftnodes.size()==0||rightnodes.size()==0){ // not BST
            return {};
        }
        else if (leftnodes[1]<root->val&&rightnodes[0]>root->val){ // is a BST
            int sum = leftnodes[2] + rightnodes[2] + root->val;
            ans = max(ans, sum);
            return {min(root->val, leftnodes[0]), max(root->val, rightnodes[1]), sum};
        }
        else{ // not BST
            return {};
        }
    }
    
    
    int maxSumBST(TreeNode* root) {
        int ans(0);
        travel(root, ans);
        return max(0, ans);
    }
};