feat: add solutions to lc problem: No.2385 (doocs#2639)

No.2385.Amount of Time for Binary Tree to Be Infected

Author: yanglbme

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

@@ -11,40 +11,29 @@
  */
 class Solution {
 public:
-    unordered_map<int, vector<int>> g;
-
     int amountOfTime(TreeNode* root, int start) {
-        dfs(root);
-        queue<int> q{{start}};
-        unordered_set<int> vis;
-        int ans = -1;
-        while (q.size()) {
-            ++ans;
-            for (int n = q.size(); n; --n) {
-                int i = q.front();
-                q.pop();
-                vis.insert(i);
-                for (int j : g[i]) {
-                    if (!vis.count(j)) {
-                        q.push(j);
-                    }
+        unordered_map<int, vector<int>> g;
+        function<void(TreeNode*, TreeNode*)> dfs = [&](TreeNode* node, TreeNode* fa) {
+            if (!node) {
+                return;
+            }
+            if (fa) {
+                g[node->val].push_back(fa->val);
+                g[fa->val].push_back(node->val);
+            }
+            dfs(node->left, node);
+            dfs(node->right, node);
+        };
+        function<int(int, int)> dfs2 = [&](int node, int fa) -> int {
+            int ans = 0;
+            for (int nxt : g[node]) {
+                if (nxt != fa) {
+                    ans = max(ans, 1 + dfs2(nxt, node));
                 }
             }
-        }
-        return ans;
-    }
-
-    void dfs(TreeNode* root) {
-        if (!root) return;
-        if (root->left) {
-            g[root->val].push_back(root->left->val);
-            g[root->left->val].push_back(root->val);
-        }
-        if (root->right) {
-            g[root->val].push_back(root->right->val);
-            g[root->right->val].push_back(root->val);
-        }
-        dfs(root->left);
-        dfs(root->right);
+            return ans;
+        };
+        dfs(root, nullptr);
+        return dfs2(start, -1);
     }
 };

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

@@ -8,39 +8,27 @@
  */
 func amountOfTime(root *TreeNode, start int) int {
 	g := map[int][]int{}
-	var dfs func(*TreeNode)
-	dfs = func(root *TreeNode) {
-		if root == nil {
+	var dfs func(*TreeNode, *TreeNode)
+	dfs = func(node, fa *TreeNode) {
+		if node == nil {
 			return
 		}
-		if root.Left != nil {
-			g[root.Val] = append(g[root.Val], root.Left.Val)
-			g[root.Left.Val] = append(g[root.Left.Val], root.Val)
+		if fa != nil {
+			g[node.Val] = append(g[node.Val], fa.Val)
+			g[fa.Val] = append(g[fa.Val], node.Val)
 		}
-		if root.Right != nil {
-			g[root.Val] = append(g[root.Val], root.Right.Val)
-			g[root.Right.Val] = append(g[root.Right.Val], root.Val)
-		}
-		dfs(root.Left)
-		dfs(root.Right)
+		dfs(node.Left, node)
+		dfs(node.Right, node)
 	}
-
-	dfs(root)
-	q := []int{start}
-	ans := -1
-	vis := map[int]bool{}
-	for len(q) > 0 {
-		ans++
-		for n := len(q); n > 0; n-- {
-			i := q[0]
-			q = q[1:]
-			vis[i] = true
-			for _, j := range g[i] {
-				if !vis[j] {
-					q = append(q, j)
-				}
+	var dfs2 func(int, int) int
+	dfs2 = func(node, fa int) (ans int) {
+		for _, nxt := range g[node] {
+			if nxt != fa {
+				ans = max(ans, 1+dfs2(nxt, node))
 			}
 		}
+		return
 	}
-	return ans
+	dfs(root, nil)
+	return dfs2(start, -1)
 }

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

@@ -17,41 +17,29 @@ class Solution {
     private Map<Integer, List<Integer>> g = new HashMap<>();
 
     public int amountOfTime(TreeNode root, int start) {
-        dfs(root);
-        Deque<Integer> q = new ArrayDeque<>();
-        Set<Integer> vis = new HashSet<>();
-        q.offer(start);
-        int ans = -1;
-        while (!q.isEmpty()) {
-            ++ans;
-            for (int n = q.size(); n > 0; --n) {
-                int i = q.pollFirst();
-                vis.add(i);
-                if (g.containsKey(i)) {
-                    for (int j : g.get(i)) {
-                        if (!vis.contains(j)) {
-                            q.offer(j);
-                        }
-                    }
-                }
-            }
-        }
-        return ans;
+        dfs(root, null);
+        return dfs2(start, -1);
     }
 
-    private void dfs(TreeNode root) {
-        if (root == null) {
+    private void dfs(TreeNode node, TreeNode fa) {
+        if (node == null) {
             return;
         }
-        if (root.left != null) {
-            g.computeIfAbsent(root.val, k -> new ArrayList<>()).add(root.left.val);
-            g.computeIfAbsent(root.left.val, k -> new ArrayList<>()).add(root.val);
+        if (fa != null) {
+            g.computeIfAbsent(node.val, k -> new ArrayList<>()).add(fa.val);
+            g.computeIfAbsent(fa.val, k -> new ArrayList<>()).add(node.val);
         }
-        if (root.right != null) {
-            g.computeIfAbsent(root.val, k -> new ArrayList<>()).add(root.right.val);
-            g.computeIfAbsent(root.right.val, k -> new ArrayList<>()).add(root.val);
+        dfs(node.left, node);
+        dfs(node.right, node);
+    }
+
+    private int dfs2(int node, int fa) {
+        int ans = 0;
+        for (int nxt : g.getOrDefault(node, List.of())) {
+            if (nxt != fa) {
+                ans = Math.max(ans, 1 + dfs2(nxt, node));
+            }
         }
-        dfs(root.left);
-        dfs(root.right);
+        return ans;
     }
 }

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

@@ -6,29 +6,22 @@
 #         self.right = right
 class Solution:
     def amountOfTime(self, root: Optional[TreeNode], start: int) -> int:
-        def dfs(root):
-            if root is None:
+        def dfs(node: Optional[TreeNode], fa: Optional[TreeNode]):
+            if node is None:
                 return
-            if root.left:
-                g[root.val].append(root.left.val)
-                g[root.left.val].append(root.val)
-            if root.right:
-                g[root.val].append(root.right.val)
-                g[root.right.val].append(root.val)
-            dfs(root.left)
-            dfs(root.right)
+            if fa:
+                g[node.val].append(fa.val)
+                g[fa.val].append(node.val)
+            dfs(node.left, node)
+            dfs(node.right, node)
+
+        def dfs2(node: int, fa: int) -> int:
+            ans = 0
+            for nxt in g[node]:
+                if nxt != fa:
+                    ans = max(ans, 1 + dfs2(nxt, node))
+            return ans
 
         g = defaultdict(list)
-        dfs(root)
-        vis = set()
-        q = deque([start])
-        ans = -1
-        while q:
-            ans += 1
-            for _ in range(len(q)):
-                i = q.popleft()
-                vis.add(i)
-                for j in g[i]:
-                    if j not in vis:
-                        q.append(j)
-        return ans
+        dfs(root, None)
+        return dfs2(start, -1)

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

@@ -13,28 +13,33 @@
  */
 
 function amountOfTime(root: TreeNode | null, start: number): number {
-    const map = new Map<number, number[]>();
-    const create = ({ val, left, right }: TreeNode) => {
-        if (left != null) {
-            map.set(val, [...(map.get(val) ?? []), left.val]);
-            map.set(left.val, [...(map.get(left.val) ?? []), val]);
-            create(left);
+    const g: Map<number, number[]> = new Map();
+    const dfs = (node: TreeNode | null, fa: TreeNode | null) => {
+        if (!node) {
+            return;
         }
-        if (right != null) {
-            map.set(val, [...(map.get(val) ?? []), right.val]);
-            map.set(right.val, [...(map.get(right.val) ?? []), val]);
-            create(right);
+        if (fa) {
+            if (!g.has(node.val)) {
+                g.set(node.val, []);
+            }
+            g.get(node.val)!.push(fa.val);
+            if (!g.has(fa.val)) {
+                g.set(fa.val, []);
+            }
+            g.get(fa.val)!.push(node.val);
         }
+        dfs(node.left, node);
+        dfs(node.right, node);
     };
-    create(root);
-    const dfs = (st: number, fa: number) => {
-        let res = 0;
-        for (const v of map.get(st) ?? []) {
-            if (v !== fa) {
-                res = Math.max(res, dfs(v, st) + 1);
+    const dfs2 = (node: number, fa: number): number => {
+        let ans = 0;
+        for (const nxt of g.get(node) || []) {
+            if (nxt !== fa) {
+                ans = Math.max(ans, 1 + dfs2(nxt, node));
             }
         }
-        return res;
+        return ans;
     };
-    return dfs(start, -1);
+    dfs(root, null);
+    return dfs2(start, -1);
 }