【LeetCode】Binary Tree Maximum Path Sum

/**
 * 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 maxSum;
    Solution()
    {
        maxSum = INT_MIN;
    }
    int maxPathSum(TreeNode *root)
    {
        Helper(root);
        return maxSum;
    }
    int Helper(TreeNode *root) 
    {//return the maxSum containing root
     //if the maxSum without root is the true answer, update the maxSum directly
        if(root == NULL)
            return 0;
        else if(root->left == NULL && root->right == NULL)
        {
            //no child, return the root->val and maybe update the maxSum
            maxSum = (maxSum >= root->val) ? maxSum : root->val;
            return root->val;
        }
        else if(root->left != NULL && root->right == NULL)
        {
            int left = Helper(root->left);
            //return value must contain root->val
            //if left <= 0, drop it
            int tmp = root->val+max(0,left);
            maxSum = (maxSum >= tmp) ? maxSum : tmp;
            return tmp;
        }
        else if(root->left == NULL && root->right != NULL)
        {
            int right = Helper(root->right);
            //return value must contain root->val
            //if right <= 0, drop it
            int tmp = root->val+max(0,right);
            maxSum = (maxSum >= tmp) ? maxSum : tmp;
            return tmp;
        }
        else
        {
            int left = Helper(root->left);
            int right = Helper(root->right);
            //if left or right <= 0, drop it
            int tmp = root->val+max(0,left)+max(0,right);
            maxSum = (maxSum >= tmp) ? maxSum : tmp;
            //attention here! return value contain at most one child
            return root->val+max(0, max(left,right));
        }
    }
};