LeetCode124 Binary Tree Maximum Path Sum

详细见：leetcode.com/problems/binary-tree-maximum-path-sum

Java Solution:
github

package leetcode;

import tools.TreeNode辅助.TreeNode;

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

/**
* @author zxwtry
* @email zxwtry@qq.com
* @project OJ
* @package leetcode
* @file P124_BinaryTreeMaximumPathSum.java
* @type P124_BinaryTreeMaximumPathSum
* @date 2017年5月7日 下午10:02:15
* @details Solution: AC 3ms 19.84%
*/
public class P124_BinaryTreeMaximumPathSum {
static class Solution {
public int maxPathSum(TreeNode root) {
if (root == null) return 0;
int[] ans = {Integer.MIN_VALUE};
search(root, ans);
return ans[0];
}
private int search(TreeNode root, int[] ans) {
if (root == null) return 0;
int lv = Math.max(0, search(root.left, ans));
int rv = Math.max(0, search(root.right, ans));
ans[0] = Math.max(ans[0], lv+rv+root.val);
return Math.max(lv, rv) + root.val;
}
}
}


C Solution:
github

/*
url: leetcode.com/problems/binary-tree-maximum-path-sum
AC 15ms 59.26%
*/

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
};

typedef struct TreeNode stn;
typedef struct TreeNode * ptn;

int _max(int a, int b) {
return a < b ? b : a;
}

int search(ptn n, int* m) {
int lv = 0, rv = 0;
if (n == NULL) return 0;
lv = search(n->left, m);
rv = search(n->right, m);
*m = _max(*m, lv + rv + n->val);
return _max(_max(_max(lv, rv), 0) + n->val, 0);
}

int maxPathSum(ptn n) {
int m = INT_MIN;
if (n == NULL) return 0;
search(n, &m);
return m;
}

Python Solution:
github

#coding=utf-8

'''
url: leetcode.com/problems/binary-tree-maximum-path-sum
@author: zxwtry
@email: zxwtry@qq.com
@date: 2017年5月10日
@details: Solution: 222ms 16.58%
'''

class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None

class Solution(object):
def search(self, n, ans):
if n == None: return 0
lv = max(self.search(n.left, ans), 0)
rv = max(self.search(n.right, ans), 0)
ans[0] = max(ans[0], lv+rv+n.val)
return max(lv, rv) + n.val

def maxPathSum(self, n):
"""
:type n: TreeNode
:rtype: int
"""
ans = [-(1 << 31)]
self.search(n, ans)
return 0 if n == None else ans[0]

if __name__ == "__main__":
t0 = TreeNode(-1)
print(Solution().maxPathSum(t0))
print(Solution().maxPathSum(None))