[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 maxPathSum(TreeNode *root) {
        if(root==NULL)
            return 0;
        set<int> s;
        return recursion(root,root,s);
    }
private:
    int recursion(TreeNode *p,TreeNode *root,set<int> &s){
        
        int left = 0 ,right=0 ,parent = p->val;
        int max = p->val;
        if(p->left==NULL && p->right==NULL)
            return max;
        if(p->left)
            left = recursion(p->left,root,s);
        if(p->right)
            right = recursion(p->right,root,s);

        if(left>max && p->left)
            s.insert(left);
        if(right>max && p->right)
            s.insert(right);
        if(left+parent>max)
            max = left+parent;
        if(right+parent>max)
            max = right+parent;
        if(right+left+parent>max)
            s.insert(right+left+parent);

        if(p==root && !s.empty()){
            set<int>::iterator iter = s.end();
            iter--;
            return  (max>(*iter)?max:(*iter));
        }
        return max;
    }
};