LeetCode OJ-- Binary Tree Maximum Path Sum ***

https://oj.leetcode.com/problems/binary-tree-maximum-path-sum/

给一棵二叉树，路径可以从任一点起，到任一点结束，但是可以连成一个路径的。求路径上最大和。

一般来说，路径是 V 字状的， 递归解的话， 每个点记录它的 左右子树的最大 V 值，并且和其的 V值相比较， 选最大的那个返回。

同时，为了计算它自己的 V 值，需要保留着，它左子树的 最大 path和，右子树的最大 path 和，这个path指的是 直的，没拐弯的。

注意，要对路径的值为负数的时候的处理。

/**
 * 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 ;

        int ans = ;
        calcV(root, ans);
        return ans;
    }
    // return data is the biggest path
    int calcV(TreeNode* root, int &current_biggest_v)
    {
        if(root == NULL)
        {
            current_biggest_v = ;
            return ;
        }
        if(root->left == NULL && root->right == NULL)
        {
            current_biggest_v = root->val;
            return root->val;
        }
        int left_biggest_v;
        int right_biggest_v;

        int left_path = calcV(root->left, left_biggest_v);
        int right_path = calcV(root->right, right_biggest_v);

        int ret_val = ;

        ret_val = max(left_path, right_path);
        ret_val = max(ret_val, );
        ret_val = ret_val + root->val;

        // with ? statements, with should add bracks
        int current_v = (left_path>? left_path:) +( right_path>? right_path:) + root->val;

        if(root->left && root->right == NULL)
            current_biggest_v = max(left_biggest_v, current_v);
        else if(root->right && root->left == NULL)
            current_biggest_v = max(right_biggest_v, current_v);
        else
        {
            current_biggest_v = max(left_biggest_v, right_biggest_v);
            current_biggest_v = max(current_biggest_v, current_v);
        }

        return ret_val;
    }
};