LeetCode——124. Binary Tree Maximum Path Sum（C++)

最新推荐文章于 2022-12-06 20:36:14 发布

begforgood

最新推荐文章于 2022-12-06 20:36:14 发布

阅读量136

点赞数

分类专栏： Leetcode 笔记文章标签： leetcode c++ 深度优先

本文链接：https://blog.csdn.net/begforgood/article/details/125333112

版权

Leetcode 同时被 2 个专栏收录

11 篇文章 0 订阅

订阅专栏

笔记

10 篇文章 0 订阅

订阅专栏

LeetCode——124. Binary Tree Maximum Path Sum（C++)
Description:
A path in a binary tree is a sequence of nodes where each pair of adjacent nodes in the sequence has an edge connecting them. A node can only appear in the sequence at most once. Note that the path does not need to pass through the root.
The path sum of a path is the sum of the node’s values in the path.
Given the root of a binary tree, return the maximum path sum of any non-empty path.
Example 1:
在这里插入图片描述 Input: root = [1,2,3]
Output: 6
Explanation: The optimal path is 2 -> 1 -> 3 with a path sum of 2 + 1 + 3 = 6.
Example 2:

Input: root = [-10,9,20,null,null,15,7]
Output: 42
Explanation: The optimal path is 15 -> 20 -> 7 with a path sum of 15 + 20 + 7 = 42.
Constraints:
The number of nodes in the tree is in the range [1, 3 * 104].
-1000 <= Node.val <= 1000

解题思路；
每个点都只能走一次，那就表明除了最顶部的根，其余所有点只能要么加左子值，要么加右子值，或者都不加，所以利用后根遍历，从下面往上吸收值，用一个map记录一下吸的左还是右；
吸收完之后再先根遍历，看以当前点为根，把另一边加或者不加上后的路径值大小。
最后返回最大路径值。
代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    int dfs(TreeNode* cur,unordered_map<TreeNode*,int>& mp)
    {
        if(cur==NULL)return 0;
        int lv=dfs(cur->left,mp);         //左子max值
        int rv=dfs(cur->right,mp);        //右子max值
        if(lv<0&&rv<0)                   //两子都小于零就不吸收上来
        {
            mp[cur]=0;                   //吸左子标-1，吸右子标1，不吸标零
            return cur->val;
        }
        else if(lv>=0&&lv>=rv)          //左子大于零且大于右子，吸左子
        {
            mp[cur]=-1;
            cur->val=lv+cur->val;
        }
        else if(rv>=0&&lv<=rv)          //右子大于零且大于左子，吸右子
        {
            mp[cur]=1;
            cur->val=rv+cur->val;
        }
        return cur->val;
    }
    void dfsfind(TreeNode* cur,int& maxnum,unordered_map<TreeNode*,int>& mp)
    {
        if(cur==NULL)return;
        if(mp[cur]==0&&cur->val>maxnum)maxnum=cur->val;     //没吸表明左右子都小于零，只需比根值
        else if(mp[cur]==-1)                               //吸左子，就看以此为根，右子值不值得吸
        {
            if(cur->right!=NULL&&cur->right->val>=0)
            {
                if(cur->val+cur->right->val>maxnum)maxnum=cur->val+cur->right->val;
            }
            else 
                if(cur->val>maxnum)maxnum=cur->val;
        }
        else if(mp[cur]==1)
        {
            if(cur->left!=NULL&&cur->left->val>=0)
            {
                if(cur->val+cur->left->val>maxnum)maxnum=cur->val+cur->left->val;
            }
            else 
                if(cur->val>maxnum)maxnum=cur->val;
        }
        dfsfind(cur->left,maxnum,mp);
        dfsfind(cur->right,maxnum,mp);
        return;
    }
public:
    int maxPathSum(TreeNode* root) {
        unordered_map<TreeNode*,int>mp;
        dfs(root,mp);
        int maxpathnum=-99999999;
        dfsfind(root,maxpathnum,mp);
        return maxpathnum;
        
    }
};