leetcode Binary Tree Maximum Path Sum

Binary Tree Maximum Path Sum

Total Accepted: 3538 Total
Submissions: 19408My Submissions

Given a binary tree, find the maximum path sum.
The path may start and end at any node in the tree.
For example:

Given the below binary tree,

1
      / \
     2   3

Return

6

.

I'm ashamed of mistakes I made because I misunderstood the meaning of path. The path is a chain instead of a subtree. # stands for Null, the following is the wrong code :

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int max3(int a,int b,int c){
        int max1=max(a,b);
        int max2=max(max1,c);
        return max2;
    }
    int maxPathSum(TreeNode *root) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        if(root==NULL)
            return 0;
        int l,r,max1,max2,maxV,v;
        max1=max2=v=root->val;
        if(root->left!=NULL){
            l=maxPathSum(root->left);
            max1=max3(l,v,l+v);
        }
        if(root->right!=NULL){
            r=maxPathSum(root->right);
            max2=max3(r,v,r+v);         
        }
        if(root->left!=NULL&&root->right!=NULL)
            maxV=max3(max1,max2,l+r+v);
        else
            maxV=max(max1,max2);
        return maxV;
    }
};

I changed the code in the following way, whereas the code is still lengthy:

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int max3(int a,int b,int c){
        int max1=max(a,b);
        int max2=max(max1,c);
        return max2;
    }
    int max4(int a,int b,int c,int d){
        int max1=max(a,b);
        int max2=max(c,d);
        int max3=max(max1,max2);
        return max3;
    }    
    int DFS(TreeNode *root,int &res){
        
        int l=0,r=0,max1,max2,maxV,v;
        max1=max2=v=root->val;
        if(root->left!=NULL){
            l=DFS(root->left,res);
            max1=max3(l,v,l+v);
        }
        if(root->right!=NULL){
            r=DFS(root->right,res);
            max2=max3(r,v,r+v);         
        }
        if(root->left!=NULL&&root->right!=NULL)
            res=max4(max1,max2,l+r+v,res);
        else
            res=max3(max1,max2,res);
        return max3(v,v+l,v+r);        
    }
    int maxPathSum(TreeNode *root) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        int res;
        if(root==NULL)
            return 0;
        else{
            res=root->val;
            DFS(root,res);
        }
        return res;
    }
};

I find another concise version from the Internet like that:

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int res=0;
    int DFS(TreeNode *root){
        if(root==NULL)  return 0;
        int l=DFS(root->left);
        int r=DFS(root->right);
        int v=root->val;
        if(l>0) v+=l;
        if(r>0) v+=r;
        if(v>res) res=v;
        return max(root->val+max(l,r),root->val);
    }
    int maxPathSum(TreeNode *root) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        if(root==NULL)  return 0;
        res=root->val;
        DFS(root);
        return res;
    }
};