正常的思路解法,果然又超时了。
/**
* 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);
}
};