leetcode Binary Tree Maximum Path Sum

最新推荐文章于 2021-01-08 03:30:45 发布

taoqick

最新推荐文章于 2021-01-08 03:30:45 发布

阅读量1.3k

点赞数

分类专栏： c++ leetcode 算法

本文链接：https://blog.csdn.net/taoqick/article/details/12619435

版权

算法同时被 3 个专栏收录

474 篇文章 6 订阅

订阅专栏

c++

265 篇文章 1 订阅

订阅专栏

leetcode

231 篇文章 0 订阅

订阅专栏

Binary Tree Maximum Path Sum

Total Accepted: 3538 Total Submissions: 19408 My 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;
    }
};