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;    }};