Binary Tree Maximum Path Sum

递归求解，时间复杂度O(n)，空间复杂度O(logN)，参考Leetcode题解。注意递归返回的时候只能返回单侧路径的和或者根节点的值。

class Solution {
public:
    int max_sum;
    int maxPathSum(TreeNode *root) {
        max_sum = INT_MIN;
        dfs(root);
        return max_sum;
    }
    
    int dfs(TreeNode *root)
    {
        if(!root) return 0;
        int left = dfs(root->left);
        int right= dfs(root->right);
        
        int sum = root->val;
        if(left > 0) sum += left;
        if(right> 0) sum += right;
        max_sum = std::max(max_sum, sum);
        if(max(left, right)>0)
            return max(root->val+left, root->val+right);
        else
            return root->val;
    }
};

使用stack进行后序遍历，迭代求解： 参考http://blog.csdn.net/starmsg/article/details/39030379

class Solution {
public:
    int maxPathSum(TreeNode *root) {
        int max_sum = INT_MIN;
        if(root == NULL) return 0;
        unordered_map<TreeNode*, int> map;
        vector<TreeNode*> stack;
        
        TreeNode *cur = root;
        TreeNode *prev = NULL;
        
        int sum = 0;
        while(!stack.empty() || cur != NULL)
        {
            if(cur != NULL)
            {
                stack.push_back(cur);
                cur = cur->left;
            }else
            {
                cur = stack.back();
                if(cur->right == NULL || cur->right == prev)
                {
                    int left_val = (cur->left)?map[cur->left]:0;
                    int right_val = (cur->right)?map[cur->right]:0;
                    int max_val = max(left_val, right_val);
                    map[cur] = max_val>0?(max_val+cur->val):cur->val;
                    
                    sum = cur->val;
                    sum += (left_val>0)?left_val:0;
                    sum += (right_val>0)?right_val:0;
                    max_sum = std::max(max_sum, sum);
                    
                    stack.pop_back();
                    prev = cur;
                    cur = NULL;
                }
                else
                    cur = cur->right;
            }
        }
        return max_sum;
    }
};