Binary Tree Maximum Path Sum

1. 问题
   

   Given a binary tree, find the maximum path sum.

   For this problem, a path is defined as any sequence of nodes from some starting node to any node in the tree along the parent-child connections. The path does not need to go through the root.

   For example:
   Given the below binary tree,

          1
         / \
        2   3
   

   Return 6

2. 解答
   

   /**
    * Definition for a binary tree node.
    * struct TreeNode {
    *     int val;
    *     TreeNode *left;
    *     TreeNode *right;
    *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
    * };
    */
   class Solution1 {
   public:
       int maxPathSum(TreeNode* root)
       {
           if(!root) return 0;
           if(!root->left && !root->right) return root->val;
           else
           {
               int s1=maxPathSum(root->left);
               int s2=maxPathSum(root->right);
               
               max=0;
               path(root->left,0);
               int s3=max;
               
               max=0;
               path(root->right,0);
               int s4=max;
               
               if(s3+s4+root->val>s1 && s3+s4+root->val>s2)
                   return s3+s4+root->val;
               else
               {
                   return (s1>s2)?s1:s2;
               }
           }
       }
       
   public:
       void path(TreeNode *root,int sum)
       {
            if(root)
           {
             if(root->left==NULL && root->right==NULL)
             {
                 //a.push_back(root->val);
                 sum+=root->val;
                 if(sum>max)
                   max=sum;
             }
            else
             {
               sum+=root->val;
               path(root->left,sum);
               path(root->right,sum);
             }
           }
       }
   public:
      int max;
   };
   
   /**
    * 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 ans;
       int scanT(TreeNode* root){
           if(root == NULL) return 0;
           int left = scanT(root -> left);
           int right = scanT(root -> right);
           int val = root -> val;
           if(left > 0) val += left;
           if(right > 0) val += right;
           if(val > ans) ans = val;
           return max(root->val ,max(left +  root -> val , right + root -> val));
       }
       int maxPathSum(TreeNode *root) {
           // Start typing your C/C++ solution below
           // DO NOT write int main() function
           if(root == NULL) return 0;
           ans = root -> val;
           scanT(root);
           return ans;
       }
   };