forked from DaleStudy/leetcode-study
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathhaklee.py
More file actions
62 lines (51 loc) ยท 3.08 KB
/
haklee.py
File metadata and controls
62 lines (51 loc) ยท 3.08 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
"""TC: O(n), SC: O(h)
์์ด๋์ด:
- ๊ฐ ๋
ธ๋๋ฅผ ๋ถ๋ชจ, ํน์ ์์ ๋
ธ๋์ ๊ด์ ์์ ๋ถ์ํ ์ ์๋ค.
- ๋ถ๋ชจ ๋
ธ๋์ ๊ด์ ์์ ๊ฒฝ๋ก๋ฅผ ๋ง๋ค๋:
- ๋ถ๋ชจ ๋
ธ๋๋ ์์ชฝ ์์ ๋
ธ๋์ ์ฐ๊ฒฐ๋ ๊ฒฝ๋ก๋ฅผ ์๋ ๋ค๋ฆฌ ์ญํ ์ ํ ์ ์๋ค.
- ์ด๋ ์์ ๋
ธ๋๋
- ๊ฒฝ๋ก์ ํฌํจ๋์ง ์์๋ ๋๋ค. ์ด ๊ฒฝ์ฐ path์ 0๋งํผ ๊ธฐ์ฌํ๋ ๊ฒ์ผ๋ก ๋ณผ ์ ์๋ค.
- ์์ ๋
ธ๋์ ๋ ์์ ๋
ธ๋ ์ค ํ ์ชฝ์ ๊ฒฝ๋ก์ ๋ถ๋ชจ ๋
ธ๋๋ฅผ ์ด์ด์ฃผ๋ ์ญํ ์ ํ๋ค.
์๋์ ์ข ๋ ์์ธํ ์ค๋ช
.
- ์์ ๋
ธ๋์ ๊ด์ ์์ ๊ฒฝ๋ก๋ฅผ ๋ง๋ค๋:
- ์์ ๋
ธ๋๋ ๋ถ๋ชจ ๋
ธ๋์ ์ฐ๊ฒฐ๋ ์ ์์ด์ผ ํ๋ค.
- ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ์์ ์ ์์ ๋
ธ๋ ์ค ํ ์ชฝ๊ณผ๋ง ์ฐ๊ฒฐ๋์ด์์ ์ ์๋ค. ๋ง์ฝ ๋ถ๋ชจ ๋
ธ๋์
๋ณธ์ธ์ ์์ชฝ ์์ ๋
ธ๋ ๋ชจ๋์ ์ฐ๊ฒฐ๋์ด ์์ผ๋ฉด ์ด ๋
ธ๋๊ฐ ์ธ ๊ฐ๋ฆผ๊ธธ์ด ๋์ด์ ๊ฒฝ๋ก๋ฅผ ๋ง๋ค
์ ์๊ธฐ ๋๋ฌธ.
- ์์ ๋ถ์์ ํตํด ์ต๋ ๊ฒฝ๋ก๋ฅผ ๋ง๋ค๊ณ ์ถ๋ค๋ฉด, ๋ค์์ ํจ์๋ฅผ root๋ฅผ ๊ธฐ์ค์ผ๋ก ์ฌ๊ท์ ์ผ๋ก ์คํํ๋ค.
- ํน์ node๊ฐ ๋ถ๋ชจ ๋
ธ๋๊ฐ ๋์๋ค๊ณ ํ์๋ ๋ณธ์ธ์ ๊ฐ์ ๋ ์์์ max(์ต๋ ๊ฒฝ๋ก, 0) ๊ฐ์ ๋ํด์
๊ฒฝ๋ก๋ฅผ ๋ง๋ค์ด๋ณธ๋ค. ์ด ๊ฐ์ด ๊ธฐ์กด solution๋ณด๋ค ํด ๊ฒฝ์ฐ solution์ ์
๋ฐ์ดํธ.
- ํน์ node๊ฐ ์์ ๋
ธ๋๊ฐ ๋ ๊ฒฝ์ฐ ๋ณธ์ธ์ ๋ ์์ ์ค ๋ ํฐ ๊ฒฝ๋ก๋ฅผ ๋ถ๋ชจ์ ์ ๊ณตํด์ผ ํ๋ค.
๋ณธ์ธ์ ๊ฐ์ max(์ผ์ชฝ ๊ฒฝ๋ก, ์ค๋ฅธ์ชฝ ๊ฒฝ๋ก)์ ๋ํด์ ๋ฆฌํด.
SC:
- solution๊ฐ์ ๊ด๋ฆฌํ๋ค. O(1).
- ํธ์ถ ์คํ์ ํธ๋ฆฌ์ ๋์ด๋งํผ ์์ผ ์ ์๋ค. O(h).
- ์ข
ํฉํ๋ฉด O(h).
TC:
- ๊ฐ ๋
ธ๋์์ O(1) ์๊ฐ์ด ์์๋๋ ์์
์ํ.
- ๋ชจ๋ ๋
ธ๋์ ์ ๊ทผํ๋ฏ๋ก O(n).
"""
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def maxPathSum(self, root: Optional[TreeNode]) -> int:
sol = [-1001] # ๋
ธ๋์ ์ต์๊ฐ๋ณด๋ค 1 ์์ ๊ฐ. ํ ๋ฌธ์ ์ธํ
์์ -inf ์ญํ ์ ํจ.
def try_get_best_path(node):
if node is None:
# ๋
ธ๋๊ฐ ๋น์ด์์๋ ๊ฒฝ๋ก ์์. ์ด๋ ์ด ๋
ธ๋๋ก๋ถํฐ ์ป์ ์ ์๋ ์ต๋ ๊ฒฝ๋ก ๊ฐ์
# 0์ผ๋ก ์น ์ ์๋ค.
return 0
# ์ผ์ชฝ, ์ค๋ฅธ์ชฝ ๋
ธ๋๋ก๋ถํฐ ์ป์ ์ ์๋ ์ต๋ ๊ฒฝ๋ก ๊ฐ.
l = max(try_get_best_path(node.left), 0)
r = max(try_get_best_path(node.right), 0)
# ํ ๋
ธ๋๋ฅผ ๋ค๋ฆฌ ์ผ์์ ์์ชฝ ์์ ๋
ธ๋์ ๊ฒฝ๋ก๋ฅผ ์ด์์๋ ๋์ฌ ์ ์๋ ๊ฒฝ๋ก ๊ฐ์ด
# ์ต๋ ๊ฒฝ๋ก์ผ ์๋ ์๋ค. ์ด ๊ฐ์ ํ ์๋ฃจ์
๊ณผ ๋น๊ตํด์ ์
๋ฐ์ดํธ ํด์ค๋ค.
sol[0] = max(node.val + l + r, sol[0])
# ํ ๋
ธ๋์ ๋ถ๋ชจ ๋
ธ๋๊ฐ `์ด ๋
ธ๋๋ฅผ ํตํด ์ป์ ์ ์๋ ์ต๋ ๊ฒฝ๋ก ๊ฐ`์ผ๋ก ์ฌ์ฉํ ๊ฐ์ ๋ฆฌํด.
return node.val + max(l, r)
try_get_best_path(root)
return sol[0]