Skip to content

Commit 497a0b8

Browse files
maolonglongmaolonglong
committed
feat: add solutions to lc/lcof2 problem: Binary Tree Maximum Path Sum
1 parent 808b753 commit 497a0b8

File tree

11 files changed

+589
-53
lines changed

11 files changed

+589
-53
lines changed

‎lcof2/剑指 Offer II 051. 节点之和最大的路径/README.md‎

Lines changed: 133 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -49,22 +49,154 @@
4949

5050
<!-- 这里可写通用的实现逻辑 -->
5151

52+
思考二叉树递归问题的经典套路：
53+
54+
1. 终止条件（何时终止递归）
55+
2. 递归处理左右子树
56+
3. 合并左右子树的计算结果
57+
58+
对于本题，由于要满足题目对“路径”的定义，在返回当前子树对外贡献的最大路径和时，需要取 `left`，`right` 的最大值
59+
5260
<!-- tabs:start -->
5361

5462
### **Python3**
5563

5664
<!-- 这里可写当前语言的特殊实现逻辑 -->
5765

5866
```python
59-
67+
# Definition for a binary tree node.
68+
# class TreeNode:
69+
# def __init__(self, val=0, left=None, right=None):
70+
# self.val = val
71+
# self.left = left
72+
# self.right = right
73+
class Solution:
74+
def maxPathSum(self, root: TreeNode) -> int:
75+
ans = float("-inf")
76+
77+
def dfs(node: TreeNode) -> int:
78+
if not node:
79+
return 0
80+
left = max(0, dfs(node.left))
81+
right = max(0, dfs(node.right))
82+
nonlocal ans
83+
ans = max(ans, node.val + left + right)
84+
return node.val + max(left, right)
85+
86+
dfs(root)
87+
return ans
6088
```
6189

6290
### **Java**
6391

6492
<!-- 这里可写当前语言的特殊实现逻辑 -->
6593

6694
```java
95+
/**
96+
* Definition for a binary tree node.
97+
* public class TreeNode {
98+
* int val;
99+
* TreeNode left;
100+
* TreeNode right;
101+
* TreeNode() {}
102+
* TreeNode(int val) { this.val = val; }
103+
* TreeNode(int val, TreeNode left, TreeNode right) {
104+
* this.val = val;
105+
* this.left = left;
106+
* this.right = right;
107+
* }
108+
* }
109+
*/
110+
class Solution {
111+
private int ans = Integer.MIN_VALUE;
112+
113+
public int maxPathSum(TreeNode root) {
114+
dfs(root);
115+
return ans;
116+
}
117+
118+
private int dfs(TreeNode node) {
119+
if (node == null) {
120+
return 0;
121+
}
122+
int left = Math.max(0, dfs(node.left));
123+
int right = Math.max(0, dfs(node.right));
124+
ans = Math.max(ans, node.val + left + right);
125+
return node.val + Math.max(left, right);
126+
}
127+
}
128+
```
129+
130+
### **Go**
131+
132+
```go
133+
/**
134+
* Definition for a binary tree node.
135+
* type TreeNode struct {
136+
* Val int
137+
* Left *TreeNode
138+
* Right *TreeNode
139+
* }
140+
*/
141+
func maxPathSum(root *TreeNode) int {
142+
ans := math.MinInt32
143+
144+
var dfs func(*TreeNode) int
145+
dfs = func(node *TreeNode) int {
146+
if node == nil {
147+
return 0
148+
}
149+
left := max(0, dfs(node.Left))
150+
right := max(0, dfs(node.Right))
151+
ans = max(ans, node.Val+left+right)
152+
return node.Val + max(left, right)
153+
}
154+
155+
dfs(root)
156+
return ans
157+
}
158+
159+
func max(a, b int) int {
160+
if a > b {
161+
return a
162+
}
163+
return b
164+
}
165+
```
67166

167+
### **C++**
168+
169+
```cpp
170+
/**
171+
* Definition for a binary tree node.
172+
* struct TreeNode {
173+
* int val;
174+
* TreeNode *left;
175+
* TreeNode *right;
176+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
177+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
178+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
179+
* };
180+
*/
181+
class Solution {
182+
public:
183+
int maxPathSum(TreeNode* root) {
184+
int ans = INT_MIN;
185+
186+
function<int(TreeNode*)> dfs = [&](TreeNode* node) {
187+
if (node == nullptr) {
188+
return 0;
189+
}
190+
int left = max(0, dfs(node->left));
191+
int right = max(0, dfs(node->right));
192+
ans = max(ans, node->val + left + right);
193+
return node->val + max(left, right);
194+
};
195+
196+
dfs(root);
197+
return ans;
198+
}
199+
};
68200
```
69201
70202
### **...**

‎lcof2/剑指 Offer II 051. 节点之和最大的路径/Solution.cpp‎

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
8+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
9+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10+
* };
11+
*/
12+
class Solution {
13+
public:
14+
int maxPathSum(TreeNode* root) {
15+
int ans = INT_MIN;
16+
17+
function<int(TreeNode*)> dfs = [&](TreeNode* node) {
18+
if (node == nullptr) {
19+
return 0;
20+
}
21+
int left = max(0, dfs(node->left));
22+
int right = max(0, dfs(node->right));
23+
ans = max(ans, node->val + left + right);
24+
return node->val + max(left, right);
25+
};
26+
27+
dfs(root);
28+
return ans;
29+
}
30+
};

‎lcof2/剑指 Offer II 051. 节点之和最大的路径/Solution.go‎

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* type TreeNode struct {
4+
* Val int
5+
* Left *TreeNode
6+
* Right *TreeNode
7+
* }
8+
*/
9+
func maxPathSum(root *TreeNode) int {
10+
ans := math.MinInt32
11+
12+
var dfs func(*TreeNode) int
13+
dfs = func(node *TreeNode) int {
14+
if node == nil {
15+
return 0
16+
}
17+
left := max(0, dfs(node.Left))
18+
right := max(0, dfs(node.Right))
19+
ans = max(ans, node.Val+left+right)
20+
return node.Val + max(left, right)
21+
}
22+
23+
dfs(root)
24+
return ans
25+
}
26+
27+
func max(a, b int) int {
28+
if a > b {
29+
return a
30+
}
31+
return b
32+
}

‎lcof2/剑指 Offer II 051. 节点之和最大的路径/Solution.java‎

Lines changed: 33 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* public class TreeNode {
4+
* int val;
5+
* TreeNode left;
6+
* TreeNode right;
7+
* TreeNode() {}
8+
* TreeNode(int val) { this.val = val; }
9+
* TreeNode(int val, TreeNode left, TreeNode right) {
10+
* this.val = val;
11+
* this.left = left;
12+
* this.right = right;
13+
* }
14+
* }
15+
*/
16+
class Solution {
17+
private int ans = Integer.MIN_VALUE;
18+
19+
public int maxPathSum(TreeNode root) {
20+
dfs(root);
21+
return ans;
22+
}
23+
24+
private int dfs(TreeNode node) {
25+
if (node == null) {
26+
return 0;
27+
}
28+
int left = Math.max(0, dfs(node.left));
29+
int right = Math.max(0, dfs(node.right));
30+
ans = Math.max(ans, node.val + left + right);
31+
return node.val + Math.max(left, right);
32+
}
33+
}

‎lcof2/剑指 Offer II 051. 节点之和最大的路径/Solution.py‎

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
# Definition for a binary tree node.
2+
# class TreeNode:
3+
# def __init__(self, val=0, left=None, right=None):
4+
# self.val = val
5+
# self.left = left
6+
# self.right = right
7+
class Solution:
8+
def maxPathSum(self, root: TreeNode) -> int:
9+
ans = float("-inf")
10+
11+
def dfs(node: TreeNode) -> int:
12+
if not node:
13+
return 0
14+
left = max(0, dfs(node.left))
15+
right = max(0, dfs(node.right))
16+
nonlocal ans
17+
ans = max(ans, node.val + left + right)
18+
return node.val + max(left, right)
19+
20+
dfs(root)
21+
return ans

0 commit comments

Comments
 (0)