LintCode 94. Binary Tree Maximum Path Sum (分治经典题)

原创已于 2024-02-02 16:48:33 修改 · 230 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #leetcode #动态规划

于 2020-01-22 14:10:32 首次发布

algorithm-design 专栏收录该内容

817 篇文章

订阅专栏

本文探讨了在二叉树中寻找最大路径和的问题，通过递归算法实现divide and conquer策略，提供了多个版本的C++代码实现，深入解析了算法细节。

Binary Tree Maximum Path Sum

Given a binary tree, find the maximum path sum.

The path may start and end at any node in the tree.

Example
Example 1:
Input: For the following binary tree（only one node）:
2
Output：2

Example 2:
Input: For the following binary tree:

  1
 / \
2   3
	
Output: 6

解法1：递归，即divide and conquer
思路：

if leftSum >= 0, rightSum >= 0, 取max(leftSum, rightSum) + root->val
if leftSum和rightSum只有一边>0，取其与root->val的和。
if leftSum < 0, rightSum < 0, 直接返回root
同时我们要考虑到左，中，右为一条路径的情况，比如说{1,2,3}，所以
gMaxSum = max(gMaxSum, max(leftSum + rightSum + root->val, result));
代码如下：

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param root: The root of binary tree.
     * @return: An integer
     */
    int maxPathSum(TreeNode * root) {
        helper(root);
        return gMaxSum;
    }

private:
    int gMaxSum = INT_MIN;
    int helper(TreeNode * root) {
        if (!root) return 0;

        int leftSum = 0, rightSum = 0, result = 0;
        
        leftSum = helper(root->left);
        rightSum = helper(root->right);
        
        int minSideSum = min(leftSum, rightSum);
        int maxSideSum = max(leftSum, rightSum);
        if (maxSideSum < 0) {
            result = root->val;
        } else {
            result = maxSideSum + root->val;
        } 
        gMaxSum = max(gMaxSum, max(leftSum + rightSum + root->val, result)); //注意，这个只对gMaxSum有效，不更新result。
        return result;
    }
};

代码同步在
https://github.com/luqian2017/Algorithm

二刷

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param root: The root of binary tree.
     * @return: An integer
     */
    int maxPathSum(TreeNode * root) {
        helper(root);
        return g_max;
    }
private:
    int g_max = INT_MIN;
    int helper(TreeNode *root) {
        if (!root) return 0;
        int sum_left = helper(root->left);
        int sum_right = helper(root->right);
        
        g_max = max(g_max, root->val);
        g_max = max(g_max, root->val + sum_left);
        g_max = max(g_max, root->val + sum_right);
        g_max = max(g_max, root->val + sum_left + sum_right);
            
        return root->val + max(sum_left, sum_right);
    }
};

差不多的版本

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param root: The root of binary tree.
     * @return: An integer
     */
    int maxPathSum(TreeNode * root) {
        helper(root);
        return g_max;
    }
private:
    int g_max = INT_MIN;
    int helper(TreeNode *root) {
        if (!root) return 0;
        int leftSum = helper(root->left);
        int rightSum = helper(root->right);
        int ret = INT_MIN;
        ret = max(ret, root->val);
        ret = max(ret, leftSum + root->val);
        ret = max(ret, rightSum + root->val);
        
        g_max = max(g_max, ret);
        g_max = max(g_max, leftSum + rightSum + root->val);
        //return root->val + max(leftSum, rightSum);
        return ret;
    }
};

三刷：

/**
 * 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 {
public:
    int maxPathSum(TreeNode* root) {
        if (!root) return 0;
        pathSum(root);
        return gMaxPathSum;
    }
private:
    int gMaxPathSum = INT_MIN;
    int pathSum(TreeNode *root) {
        if (!root) return 0;
        int res = 0, leftPathSum = 0, rightPathSum = 0;
        gMaxPathSum = max(gMaxPathSum, root->val);
        if (!root->left && !root->right) {
            res = root->val;
        } else if (!root->left) {
            rightPathSum = pathSum(root->right);
            res = max(rightPathSum + root->val, root->val);
        } else if (!root->right) {
            leftPathSum = pathSum(root->left);
            res = max(leftPathSum + root->val, root->val);
        } else {
            leftPathSum = pathSum(root->left);
            rightPathSum = pathSum(root->right);
            gMaxPathSum = max(gMaxPathSum, max(leftPathSum, rightPathSum));
            res = max(leftPathSum, rightPathSum) + root->val;
            res = max(res, root->val);
            gMaxPathSum = max(gMaxPathSum, leftPathSum + rightPathSum + root->val);
        }
        gMaxPathSum = max(gMaxPathSum, res);
        return res;
    }    
};

四刷：

class Solution {
public:
    int maxPathSum(TreeNode* root) {
        calcPathSum(root);
        return gMaxPathSum;
    }
private:
    int gMaxPathSum = INT_MIN;
    int calcPathSum(TreeNode *root) {
        if (!root) return 0;
        int res = INT_MIN;
        res = max(res, root->val);
        int leftPathSum = 0, rightPathSum = 0;
        if (root->left) {
            leftPathSum = calcPathSum(root->left);
            res = max(res, root->val + leftPathSum);
        }
        if (root->right) {
            rightPathSum = calcPathSum(root->right);
            res = max(res, root->val + rightPathSum);
        }
        gMaxPathSum = max(gMaxPathSum, res);
        if (root->left && root->right) {
            gMaxPathSum = max(gMaxPathSum, leftPathSum + root->val + rightPathSum);
        }
        return res;
    }
};

再刷：

/**
 * 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 {
public:
    int maxPathSum(TreeNode* root) {
        oneSideMaxPath(root);
        return gMaxPathSum;
    }
private:
    int gMaxPathSum = INT_MIN;
    int oneSideMaxPath(TreeNode *root) {
        if (!root) return 0;
        int leftMaxPath = max(0, oneSideMaxPath(root->left));
        int rightMaxPath = max(0, oneSideMaxPath(root->right));
        gMaxPathSum = max(gMaxPathSum, root->val + leftMaxPath + rightMaxPath);
        return root->val + max(leftMaxPath, rightMaxPath);
    }
};