Skip to content

Commit e23ae77

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.2385 (doocs#2639)
No.2385.Amount of Time for Binary Tree to Be Infected
1 parent b81124b commit e23ae77

File tree

14 files changed

+294
-947
lines changed

14 files changed

+294
-947
lines changed

‎solution/2300-2399/2385.Amount of Time for Binary Tree to Be Infected/README.md

Lines changed: 97 additions & 318 deletions
Large diffs are not rendered by default.

‎solution/2300-2399/2385.Amount of Time for Binary Tree to Be Infected/README_EN.md

Lines changed: 100 additions & 313 deletions
Large diffs are not rendered by default.

‎solution/2300-2399/2385.Amount of Time for Binary Tree to Be Infected/Solution.cpp

Lines changed: 21 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -11,40 +11,29 @@
1111
*/
1212
class Solution {
1313
public:
14-
unordered_map<int, vector<int>> g;
15-
1614
int amountOfTime(TreeNode* root, int start) {
17-
dfs(root);
18-
queue<int> q{{start}};
19-
unordered_set<int> vis;
20-
int ans = -1;
21-
while (q.size()) {
22-
++ans;
23-
for (int n = q.size(); n; --n) {
24-
int i = q.front();
25-
q.pop();
26-
vis.insert(i);
27-
for (int j : g[i]) {
28-
if (!vis.count(j)) {
29-
q.push(j);
30-
}
15+
unordered_map<int, vector<int>> g;
16+
function<void(TreeNode*, TreeNode*)> dfs = [&](TreeNode* node, TreeNode* fa) {
17+
if (!node) {
18+
return;
19+
}
20+
if (fa) {
21+
g[node->val].push_back(fa->val);
22+
g[fa->val].push_back(node->val);
23+
}
24+
dfs(node->left, node);
25+
dfs(node->right, node);
26+
};
27+
function<int(int, int)> dfs2 = [&](int node, int fa) -> int {
28+
int ans = 0;
29+
for (int nxt : g[node]) {
30+
if (nxt != fa) {
31+
ans = max(ans, 1 + dfs2(nxt, node));
3132
}
3233
}
33-
}
34-
return ans;
35-
}
36-
37-
void dfs(TreeNode* root) {
38-
if (!root) return;
39-
if (root->left) {
40-
g[root->val].push_back(root->left->val);
41-
g[root->left->val].push_back(root->val);
42-
}
43-
if (root->right) {
44-
g[root->val].push_back(root->right->val);
45-
g[root->right->val].push_back(root->val);
46-
}
47-
dfs(root->left);
48-
dfs(root->right);
34+
return ans;
35+
};
36+
dfs(root, nullptr);
37+
return dfs2(start, -1);
4938
}
5039
};

‎solution/2300-2399/2385.Amount of Time for Binary Tree to Be Infected/Solution.go

Lines changed: 16 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -8,39 +8,27 @@
88
*/
99
func amountOfTime(root *TreeNode, start int) int {
1010
g := map[int][]int{}
11-
var dfs func(*TreeNode)
12-
dfs = func(root *TreeNode) {
13-
if root == nil {
11+
var dfs func(*TreeNode, *TreeNode)
12+
dfs = func(node, fa *TreeNode) {
13+
if node == nil {
1414
return
1515
}
16-
if root.Left != nil {
17-
g[root.Val] = append(g[root.Val], root.Left.Val)
18-
g[root.Left.Val] = append(g[root.Left.Val], root.Val)
16+
if fa != nil {
17+
g[node.Val] = append(g[node.Val], fa.Val)
18+
g[fa.Val] = append(g[fa.Val], node.Val)
1919
}
20-
if root.Right != nil {
21-
g[root.Val] = append(g[root.Val], root.Right.Val)
22-
g[root.Right.Val] = append(g[root.Right.Val], root.Val)
23-
}
24-
dfs(root.Left)
25-
dfs(root.Right)
20+
dfs(node.Left, node)
21+
dfs(node.Right, node)
2622
}
27-
28-
dfs(root)
29-
q := []int{start}
30-
ans := -1
31-
vis := map[int]bool{}
32-
for len(q) > 0 {
33-
ans++
34-
for n := len(q); n > 0; n-- {
35-
i := q[0]
36-
q = q[1:]
37-
vis[i] = true
38-
for _, j := range g[i] {
39-
if !vis[j] {
40-
q = append(q, j)
41-
}
23+
var dfs2 func(int, int) int
24+
dfs2 = func(node, fa int) (ans int) {
25+
for _, nxt := range g[node] {
26+
if nxt != fa {
27+
ans = max(ans, 1+dfs2(nxt, node))
4228
}
4329
}
30+
return
4431
}
45-
return ans
32+
dfs(root, nil)
33+
return dfs2(start, -1)
4634
}

‎solution/2300-2399/2385.Amount of Time for Binary Tree to Be Infected/Solution.java

Lines changed: 18 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -17,41 +17,29 @@ class Solution {
1717
private Map<Integer, List<Integer>> g = new HashMap<>();
1818

1919
public int amountOfTime(TreeNode root, int start) {
20-
dfs(root);
21-
Deque<Integer> q = new ArrayDeque<>();
22-
Set<Integer> vis = new HashSet<>();
23-
q.offer(start);
24-
int ans = -1;
25-
while (!q.isEmpty()) {
26-
++ans;
27-
for (int n = q.size(); n > 0; --n) {
28-
int i = q.pollFirst();
29-
vis.add(i);
30-
if (g.containsKey(i)) {
31-
for (int j : g.get(i)) {
32-
if (!vis.contains(j)) {
33-
q.offer(j);
34-
}
35-
}
36-
}
37-
}
38-
}
39-
return ans;
20+
dfs(root, null);
21+
return dfs2(start, -1);
4022
}
4123

42-
private void dfs(TreeNode root) {
43-
if (root == null) {
24+
private void dfs(TreeNode node, TreeNode fa) {
25+
if (node == null) {
4426
return;
4527
}
46-
if (root.left != null) {
47-
g.computeIfAbsent(root.val, k -> new ArrayList<>()).add(root.left.val);
48-
g.computeIfAbsent(root.left.val, k -> new ArrayList<>()).add(root.val);
28+
if (fa != null) {
29+
g.computeIfAbsent(node.val, k -> new ArrayList<>()).add(fa.val);
30+
g.computeIfAbsent(fa.val, k -> new ArrayList<>()).add(node.val);
4931
}
50-
if (root.right != null) {
51-
g.computeIfAbsent(root.val, k -> new ArrayList<>()).add(root.right.val);
52-
g.computeIfAbsent(root.right.val, k -> new ArrayList<>()).add(root.val);
32+
dfs(node.left, node);
33+
dfs(node.right, node);
34+
}
35+
36+
private int dfs2(int node, int fa) {
37+
int ans = 0;
38+
for (int nxt : g.getOrDefault(node, List.of())) {
39+
if (nxt != fa) {
40+
ans = Math.max(ans, 1 + dfs2(nxt, node));
41+
}
5342
}
54-
dfs(root.left);
55-
dfs(root.right);
43+
return ans;
5644
}
5745
}

‎solution/2300-2399/2385.Amount of Time for Binary Tree to Be Infected/Solution.py

Lines changed: 16 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -6,29 +6,22 @@
66
# self.right = right
77
class Solution:
88
def amountOfTime(self, root: Optional[TreeNode], start: int) -> int:
9-
def dfs(root):
10-
if root is None:
9+
def dfs(node: Optional[TreeNode], fa: Optional[TreeNode]):
10+
if node is None:
1111
return
12-
if root.left:
13-
g[root.val].append(root.left.val)
14-
g[root.left.val].append(root.val)
15-
if root.right:
16-
g[root.val].append(root.right.val)
17-
g[root.right.val].append(root.val)
18-
dfs(root.left)
19-
dfs(root.right)
12+
if fa:
13+
g[node.val].append(fa.val)
14+
g[fa.val].append(node.val)
15+
dfs(node.left, node)
16+
dfs(node.right, node)
17+
18+
def dfs2(node: int, fa: int) -> int:
19+
ans = 0
20+
for nxt in g[node]:
21+
if nxt != fa:
22+
ans = max(ans, 1 + dfs2(nxt, node))
23+
return ans
2024

2125
g = defaultdict(list)
22-
dfs(root)
23-
vis = set()
24-
q = deque([start])
25-
ans = -1
26-
while q:
27-
ans += 1
28-
for _ in range(len(q)):
29-
i = q.popleft()
30-
vis.add(i)
31-
for j in g[i]:
32-
if j not in vis:
33-
q.append(j)
34-
return ans
26+
dfs(root, None)
27+
return dfs2(start, -1)

‎solution/2300-2399/2385.Amount of Time for Binary Tree to Be Infected/Solution.ts

Lines changed: 23 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -13,28 +13,33 @@
1313
*/
1414

1515
function amountOfTime(root: TreeNode | null, start: number): number {
16-
const map = new Map<number, number[]>();
17-
const create = ({ val, left, right }: TreeNode) => {
18-
if (left != null) {
19-
map.set(val, [...(map.get(val) ?? []), left.val]);
20-
map.set(left.val, [...(map.get(left.val) ?? []), val]);
21-
create(left);
16+
const g: Map<number, number[]> = new Map();
17+
const dfs = (node: TreeNode | null, fa: TreeNode | null) => {
18+
if (!node) {
19+
return;
2220
}
23-
if (right != null) {
24-
map.set(val, [...(map.get(val) ?? []), right.val]);
25-
map.set(right.val, [...(map.get(right.val) ?? []), val]);
26-
create(right);
21+
if (fa) {
22+
if (!g.has(node.val)) {
23+
g.set(node.val, []);
24+
}
25+
g.get(node.val)!.push(fa.val);
26+
if (!g.has(fa.val)) {
27+
g.set(fa.val, []);
28+
}
29+
g.get(fa.val)!.push(node.val);
2730
}
31+
dfs(node.left, node);
32+
dfs(node.right, node);
2833
};
29-
create(root);
30-
const dfs = (st: number, fa: number) => {
31-
let res = 0;
32-
for (const v of map.get(st) ?? []) {
33-
if (v !== fa) {
34-
res = Math.max(res, dfs(v, st) + 1);
34+
const dfs2 = (node: number, fa: number): number => {
35+
let ans = 0;
36+
for (const nxt of g.get(node) || []) {
37+
if (nxt !== fa) {
38+
ans = Math.max(ans, 1 + dfs2(nxt, node));
3539
}
3640
}
37-
return res;
41+
return ans;
3842
};
39-
return dfs(start, -1);
43+
dfs(root, null);
44+
return dfs2(start, -1);
4045
}

‎solution/2300-2399/2385.Amount of Time for Binary Tree to Be Infected/Solution2.cpp

Lines changed: 0 additions & 44 deletions
This file was deleted.

‎solution/2300-2399/2385.Amount of Time for Binary Tree to Be Infected/Solution2.go

Lines changed: 0 additions & 41 deletions
This file was deleted.

0 commit comments

Comments
 (0)
pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy