feat: add solution 3373. Maximize the Number of Target Nodes After Connecting Trees II

Author: tzuyi0817

solutions/3373. Maximize the Number of Target Nodes After Connecting Trees II/README.md

@@ -0,0 +1,135 @@
+# [3373. Maximize the Number of Target Nodes After Connecting Trees II](https://leetcode.com/problems/maximize-the-number-of-target-nodes-after-connecting-trees-ii)
+
+## Description
+
+<div class="elfjS" data-track-load="description_content"><p>There exist two <strong>undirected </strong>trees with <code>n</code> and <code>m</code> nodes, labeled from <code>[0, n - 1]</code> and <code>[0, m - 1]</code>, respectively.</p>
+
+<p>You are given two 2D integer arrays <code>edges1</code> and <code>edges2</code> of lengths <code>n - 1</code> and <code>m - 1</code>, respectively, where <code>edges1[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> indicates that there is an edge between nodes <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code> in the first tree and <code>edges2[i] = [u<sub>i</sub>, v<sub>i</sub>]</code> indicates that there is an edge between nodes <code>u<sub>i</sub></code> and <code>v<sub>i</sub></code> in the second tree.</p>
+
+<p>Node <code>u</code> is <strong>target</strong> to node <code>v</code> if the number of edges on the path from <code>u</code> to <code>v</code> is even.&nbsp;<strong>Note</strong> that a node is <em>always</em> <strong>target</strong> to itself.</p>
+
+<p>Return an array of <code>n</code> integers <code>answer</code>, where <code>answer[i]</code> is the <strong>maximum</strong> possible number of nodes that are <strong>target</strong> to node <code>i</code> of the first tree if you had to connect one node from the first tree to another node in the second tree.</p>
+
+<p><strong>Note</strong> that queries are independent from each other. That is, for every query you will remove the added edge before proceeding to the next query.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">edges1 = [[0,1],[0,2],[2,3],[2,4]], edges2 = [[0,1],[0,2],[0,3],[2,7],[1,4],[4,5],[4,6]]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[8,7,7,8,8]</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<ul>
+	<li>For <code>i = 0</code>, connect node 0 from the first tree to node 0 from the second tree.</li>
+	<li>For <code>i = 1</code>, connect node 1 from the first tree to node 4 from the second tree.</li>
+	<li>For <code>i = 2</code>, connect node 2 from the first tree to node 7 from the second tree.</li>
+	<li>For <code>i = 3</code>, connect node 3 from the first tree to node 0 from the second tree.</li>
+	<li>For <code>i = 4</code>, connect node 4 from the first tree to node 4 from the second tree.</li>
+</ul>
+<img alt="" src="https://assets.leetcode.com/uploads/2024/09/24/3982-1.png" style="width: 600px; height: 169px;"></div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">edges1 = [[0,1],[0,2],[0,3],[0,4]], edges2 = [[0,1],[1,2],[2,3]]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[3,6,6,6,6]</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>For every <code>i</code>, connect node <code>i</code> of the first tree with any node of the second tree.</p>
+<img alt="" src="https://assets.leetcode.com/uploads/2024/09/24/3928-2.png" style="height: 281px; width: 500px;"></div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= n, m &lt;= 10<sup>5</sup></code></li>
+	<li><code>edges1.length == n - 1</code></li>
+	<li><code>edges2.length == m - 1</code></li>
+	<li><code>edges1[i].length == edges2[i].length == 2</code></li>
+	<li><code>edges1[i] = [a<sub>i</sub>, b<sub>i</sub>]</code></li>
+	<li><code>0 &lt;= a<sub>i</sub>, b<sub>i</sub> &lt; n</code></li>
+	<li><code>edges2[i] = [u<sub>i</sub>, v<sub>i</sub>]</code></li>
+	<li><code>0 &lt;= u<sub>i</sub>, v<sub>i</sub> &lt; m</code></li>
+	<li>The input is generated such that <code>edges1</code> and <code>edges2</code> represent valid trees.</li>
+</ul>
+</div>
+
+<p>&nbsp;</p>
+
+## Solutions
+
+**Solution: `Depth-First Search`**
+
+- Time complexity: <em>O(m+n)</em>
+- Space complexity: <em>O(m+n)</em>
+
+<p>&nbsp;</p>
+
+### **JavaScript**
+
+```js
+/**
+ * @param {number[][]} edges1
+ * @param {number[][]} edges2
+ * @return {number[]}
+ */
+const maxTargetNodes = function (edges1, edges2) {
+  const createTree = (edge, n) => {
+    const tree = Array.from({ length: n }, () => []);
+
+    for (const [a, b] of edge) {
+      tree[a].push(b);
+      tree[b].push(a);
+    }
+
+    return tree;
+  };
+
+  const m = edges1.length + 1;
+  const n = edges2.length + 1;
+  const tree1 = createTree(edges1, m);
+  const tree2 = createTree(edges2, n);
+
+  const getNodeCount = (tree, isEven) => {
+    const count = Array.from({ length: 2 }, () => 0);
+
+    const dfsTree = (node, prev, index) => {
+      count[index] += 1;
+
+      for (const neighbor of tree[node]) {
+        if (prev === neighbor) continue;
+
+        dfsTree(neighbor, node, index ^ 1);
+      }
+    };
+
+    dfsTree(0, -1, isEven ? 1 : 0);
+
+    return count;
+  };
+
+  const count1 = getNodeCount(tree1, true);
+  const count2 = getNodeCount(tree2, false);
+  const maxPathCount = Math.max(...count2);
+  const path = Array.from({ length: m }, () => false);
+
+  const setNodePath = (node, prev, isEven) => {
+    path[node] = isEven;
+
+    for (const neighbor of tree1[node]) {
+      if (prev === neighbor) continue;
+
+      setNodePath(neighbor, node, !isEven);
+    }
+  };
+
+  setNodePath(0, -1, true);
+
+  return path.map(isEven => maxPathCount + count1[isEven ? 1 : 0]);
+};
+```

solutions/3373. Maximize the Number of Target Nodes After Connecting Trees II/solution.js

@@ -0,0 +1,59 @@
+/**
+ * @param {number[][]} edges1
+ * @param {number[][]} edges2
+ * @return {number[]}
+ */
+const maxTargetNodes = function (edges1, edges2) {
+  const createTree = (edge, n) => {
+    const tree = Array.from({ length: n }, () => []);
+
+    for (const [a, b] of edge) {
+      tree[a].push(b);
+      tree[b].push(a);
+    }
+
+    return tree;
+  };
+
+  const m = edges1.length + 1;
+  const n = edges2.length + 1;
+  const tree1 = createTree(edges1, m);
+  const tree2 = createTree(edges2, n);
+
+  const getNodeCount = (tree, isEven) => {
+    const count = Array.from({ length: 2 }, () => 0);
+
+    const dfsTree = (node, prev, index) => {
+      count[index] += 1;
+
+      for (const neighbor of tree[node]) {
+        if (prev === neighbor) continue;
+
+        dfsTree(neighbor, node, index ^ 1);
+      }
+    };
+
+    dfsTree(0, -1, isEven ? 1 : 0);
+
+    return count;
+  };
+
+  const count1 = getNodeCount(tree1, true);
+  const count2 = getNodeCount(tree2, false);
+  const maxPathCount = Math.max(...count2);
+  const path = Array.from({ length: m }, () => false);
+
+  const setNodePath = (node, prev, isEven) => {
+    path[node] = isEven;
+
+    for (const neighbor of tree1[node]) {
+      if (prev === neighbor) continue;
+
+      setNodePath(neighbor, node, !isEven);
+    }
+  };
+
+  setNodePath(0, -1, true);
+
+  return path.map(isEven => maxPathCount + count1[isEven ? 1 : 0]);
+};