Binary Tree Maximum Path Sum

Given a binary tree, find the maximum path sum.

The path may start and end at any node in the tree.

For example:
Given the below binary tree,

       1
      / \
     2   3

Return 6.

这题真心纠结了很久！想的方法也挺多的，递归，非递归都有！现在总结一下自己的思路。
首先，我想到的是用递归，把可能的最大值都用一个vector存起来，最后对vector做个排序，然后取最后一个就好了，不过以失败告终！通过了87/92个测试用例，原因很简单，我的这个方法一定会把根节点算进去，而题目当中是任意两个结点，所以.....
然后我想到飞递归的方法，这次也是考虑不周，我把根节点的左右子树当中每层的最大值取出来分别放到一个vector，然后对左vector做一个反转，加上根节点，再加上右子树的vector。然后就变成了数组的问题！不幸的是还是以失败告终，因为我忽略了这样破坏了树的结构，可能导致我取出来的值在树中并不是连通的！通过了66/92个测试用例。

总结一下教训：写代码之前一定要深刻理解题目的要求，想到算法后 分析清楚算法的可行性！这是血的教训！

方法一：87/92（错误）

/**
 * 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, int sum,vector<int> &vec)
    {
	if (!root)
		return sum;
	vec.push_back(root->val);
	int i_left = maxPathSum(root->left,sum+root->val,vec);
	//cout << "ileft:" << i_left << endl;
	int i_right = maxPathSum(root->right,sum+root->val,vec);
	//cout << "i_right:" << i_right << endl;
	vec.push_back(i_left+i_right-root->val-2*sum);//当前根节点左右最大和
	vec.push_back(max(i_left, i_right));//当前根节点左孩子右孩子最大和
	return max(i_left, i_right);
    }
    int maxPathSum(TreeNode *root) {
	if (!root)
		return 0;
	vector<int>vec;
	int sum = maxPathSum(root,0,vec);
	/*for (int i = 0; i < vec.size();++i)
		cout << vec[i] << "      ";
	cout << endl;*/
	sort(vec.begin(),vec.end());
	return vec[vec.size()-1];
    }
};

方法二：66/92（错误）

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
	vector<int> maxElem(TreeNode *root){
	vector<int>vec;
	if (!root)
		return vec;
	TreeNode *current;
	queue<TreeNode*>temp,q;
	q.push(root);
	int max_elem = INT_MIN;
	while (!q.empty())
	{
		current = q.front();
		max_elem = max(current->val,max_elem);
		q.pop();
		if (current->left)
			temp.push(current->left);
		if (current->right)
			temp.push(current->right);
		if (!temp.empty() && q.empty())
		{
			q.swap(temp);
			vec.push_back(max_elem);
			max_elem = INT_MIN;
		}
	}
	vec.push_back(max_elem);
	return vec;
    }

    int maxPathSum(TreeNode *root) {
	if (!root)
		return 0;
	int sum=0;
	vector<int> candidate;//暂存可能是最大值的元素
	//找出左右子树每层中最大的元素
	vector<int> left_vec = maxElem(root->left);
	vector<int> right_vec = maxElem(root->right);
	//合并
	reverse(left_vec.begin(),left_vec.end());
	left_vec.push_back(root->val);
	left_vec.insert(left_vec.end(),right_vec.begin(),right_vec.end());

	for (vector<int>::iterator it = left_vec.begin(); it != left_vec.end(); ++it)
	{
	    candidate.push_back(*it);
		if (*it<0 && sum>0)
			candidate.push_back(sum);
		if (*it > 0 && sum<0)
		{
			sum = *it;
			continue;
		}
		sum += *it;
	}
	sort(candidate.begin(),candidate.end());
	return max(candidate[candidate.size()-1],sum);
}
	
}

FINAL:92/92(正确)从底往上找到最优

/**
 * 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 max_sum = INT_MIN;
int max_path_sum(TreeNode*root)
{
	if (!root)
		return 0;
	int i_left = max_path_sum(root->left);
	int i_right = max_path_sum(root->right);
	int sum = root->val;
	if (i_left > 0)
		sum += i_left;
	if (i_right > 0)
		sum += i_right;
	max_sum = max(sum,max_sum);
	return (max(i_left, i_right) > 0) ? (max(i_left, i_right) + root->val) : root->val;
}

int maxPathSum(TreeNode *root) {
	if (!root)
		return 0;
	max_path_sum(root);
	return max_sum;
}
	
};