feat: add solutions to lc problem: No.2458

solution/2400-2499/2458.Height of Binary Tree After Subtree Removal Queries/README.md

@@ -289,4 +289,104 @@ func treeQueries(root *TreeNode, queries []int) (ans []int) {
 
 <!-- solution:end -->
 
+<!-- solution:start -->
+
+### 方法二：一次 DFS + 排序
+
+<!-- tabs:start -->
+
+#### TypeScript
+
+```ts
+function treeQueries(root: TreeNode | null, queries: number[]): number[] {
+    const ans: number[] = [];
+    const levels: Map<number, [number, number][]> = new Map();
+    const valToLevel = new Map<number, number>();
+
+    const dfs = (node: TreeNode | null, level = 0): number => {
+        if (!node) return level - 1;
+
+        const max = Math.max(dfs(node.left, level + 1), dfs(node.right, level + 1));
+
+        if (!levels.has(level)) {
+            levels.set(level, []);
+        }
+        levels.get(level)?.push([max, node.val]);
+        valToLevel.set(node.val, level);
+
+        return max;
+    };
+
+    dfs(root, 0);
+
+    for (const [_, l] of levels) {
+        l.sort(([a], [b]) => b - a);
+    }
+
+    for (const q of queries) {
+        const level = valToLevel.get(q)!;
+        const maxes = levels.get(level)!;
+
+        if (maxes.length === 1) {
+            ans.push(level - 1);
+        } else {
+            const [val0, max0, max1] = [maxes[0][1], maxes[0][0], maxes[1][0]];
+            const max = val0 === q ? max1 : max0;
+            ans.push(max);
+        }
+    }
+
+    return ans;
+}
+```
+
+#### JavaScript
+
+```js
+function treeQueries(root, queries) {
+    const ans = [];
+    const levels = new Map();
+    const valToLevel = new Map();
+
+    const dfs = (node, level = 0) => {
+        if (!node) return level - 1;
+
+        const max = Math.max(dfs(node.left, level + 1), dfs(node.right, level + 1));
+
+        if (!levels.has(level)) {
+            levels.set(level, []);
+        }
+        levels.get(level)?.push([max, node.val]);
+        valToLevel.set(node.val, level);
+
+        return max;
+    };
+
+    dfs(root, 0);
+
+    for (const [_, l] of levels) {
+        l.sort(([a], [b]) => b - a);
+    }
+
+    for (const q of queries) {
+        const level = valToLevel.get(q);
+        const maxes = levels.get(level);
+
+        if (maxes.length === 1) {
+            ans.push(level - 1);
+        } else {
+            const [val0, max0, max1] = [maxes[0][1], maxes[0][0], maxes[1][0]];
+            const max = val0 === q ? max1 : max0;
+            ans.push(max);
+        }
+    }
+
+    return ans;
+}
+```
+
+<!-- tabs:end -->
+
+<!-- solution:end -->
+
 <!-- problem:end -->

solution/2400-2499/2458.Height of Binary Tree After Subtree Removal Queries/README_EN.md

@@ -283,4 +283,104 @@ func treeQueries(root *TreeNode, queries []int) (ans []int) {
 
 <!-- solution:end -->
 
+<!-- solution:start -->
+
+### Solution 2: One DFS + Sorting
+
+<!-- tabs:start -->
+
+#### TypeScript
+
+```ts
+function treeQueries(root: TreeNode | null, queries: number[]): number[] {
+    const ans: number[] = [];
+    const levels: Map<number, [number, number][]> = new Map();
+    const valToLevel = new Map<number, number>();
+
+    const dfs = (node: TreeNode | null, level = 0): number => {
+        if (!node) return level - 1;
+
+        const max = Math.max(dfs(node.left, level + 1), dfs(node.right, level + 1));
+
+        if (!levels.has(level)) {
+            levels.set(level, []);
+        }
+        levels.get(level)?.push([max, node.val]);
+        valToLevel.set(node.val, level);
+
+        return max;
+    };
+
+    dfs(root, 0);
+
+    for (const [_, l] of levels) {
+        l.sort(([a], [b]) => b - a);
+    }
+
+    for (const q of queries) {
+        const level = valToLevel.get(q)!;
+        const maxes = levels.get(level)!;
+
+        if (maxes.length === 1) {
+            ans.push(level - 1);
+        } else {
+            const [val0, max0, max1] = [maxes[0][1], maxes[0][0], maxes[1][0]];
+            const max = val0 === q ? max1 : max0;
+            ans.push(max);
+        }
+    }
+
+    return ans;
+}
+```
+
+#### JavaScript
+
+```js
+function treeQueries(root, queries) {
+    const ans = [];
+    const levels = new Map();
+    const valToLevel = new Map();
+
+    const dfs = (node, level = 0) => {
+        if (!node) return level - 1;
+
+        const max = Math.max(dfs(node.left, level + 1), dfs(node.right, level + 1));
+
+        if (!levels.has(level)) {
+            levels.set(level, []);
+        }
+        levels.get(level)?.push([max, node.val]);
+        valToLevel.set(node.val, level);
+
+        return max;
+    };
+
+    dfs(root, 0);
+
+    for (const [_, l] of levels) {
+        l.sort(([a], [b]) => b - a);
+    }
+
+    for (const q of queries) {
+        const level = valToLevel.get(q);
+        const maxes = levels.get(level);
+
+        if (maxes.length === 1) {
+            ans.push(level - 1);
+        } else {
+            const [val0, max0, max1] = [maxes[0][1], maxes[0][0], maxes[1][0]];
+            const max = val0 === q ? max1 : max0;
+            ans.push(max);
+        }
+    }
+
+    return ans;
+}
+```
+
+<!-- tabs:end -->
+
+<!-- solution:end -->
+
 <!-- problem:end -->

solution/2400-2499/2458.Height of Binary Tree After Subtree Removal Queries/Solution2.js

@@ -0,0 +1,40 @@
+function treeQueries(root, queries) {
+    const ans = [];
+    const levels = new Map();
+    const valToLevel = new Map();
+
+    const dfs = (node, level = 0) => {
+        if (!node) return level - 1;
+
+        const max = Math.max(dfs(node.left, level + 1), dfs(node.right, level + 1));
+
+        if (!levels.has(level)) {
+            levels.set(level, []);
+        }
+        levels.get(level)?.push([max, node.val]);
+        valToLevel.set(node.val, level);
+
+        return max;
+    };
+
+    dfs(root, 0);
+
+    for (const [_, l] of levels) {
+        l.sort(([a], [b]) => b - a);
+    }
+
+    for (const q of queries) {
+        const level = valToLevel.get(q);
+        const maxes = levels.get(level);
+
+        if (maxes.length === 1) {
+            ans.push(level - 1);
+        } else {
+            const [val0, max0, max1] = [maxes[0][1], maxes[0][0], maxes[1][0]];
+            const max = val0 === q ? max1 : max0;
+            ans.push(max);
+        }
+    }
+
+    return ans;
+}

solution/2400-2499/2458.Height of Binary Tree After Subtree Removal Queries/Solution2.ts

@@ -0,0 +1,40 @@
+function treeQueries(root: TreeNode | null, queries: number[]): number[] {
+    const ans: number[] = [];
+    const levels: Map<number, [number, number][]> = new Map();
+    const valToLevel = new Map<number, number>();
+
+    const dfs = (node: TreeNode | null, level = 0): number => {
+        if (!node) return level - 1;
+
+        const max = Math.max(dfs(node.left, level + 1), dfs(node.right, level + 1));
+
+        if (!levels.has(level)) {
+            levels.set(level, []);
+        }
+        levels.get(level)?.push([max, node.val]);
+        valToLevel.set(node.val, level);
+
+        return max;
+    };
+
+    dfs(root, 0);
+
+    for (const [_, l] of levels) {
+        l.sort(([a], [b]) => b - a);
+    }
+
+    for (const q of queries) {
+        const level = valToLevel.get(q)!;
+        const maxes = levels.get(level)!;
+
+        if (maxes.length === 1) {
+            ans.push(level - 1);
+        } else {
+            const [val0, max0, max1] = [maxes[0][1], maxes[0][0], maxes[1][0]];
+            const max = val0 === q ? max1 : max0;
+            ans.push(max);
+        }
+    }
+
+    return ans;
+}