Added tasks 3370-3373

Author: javadev

src/main/kotlin/g3301_3400/s3370_smallest_number_with_all_set_bits/Solution.kt

@@ -0,0 +1,13 @@
+package g3301_3400.s3370_smallest_number_with_all_set_bits
+
+// #Easy #Math #Bit_Manipulation #2024_12_03_Time_0_ms_(100.00%)_Space_41.1_MB_(45.50%)
+
+class Solution {
+    fun smallestNumber(n: Int): Int {
+        var res = 1
+        while (res < n) {
+            res = res * 2 + 1
+        }
+        return res
+    }
+}

src/main/kotlin/g3301_3400/s3370_smallest_number_with_all_set_bits/readme.md

@@ -0,0 +1,43 @@
+3370\. Smallest Number With All Set Bits
+
+Easy
+
+You are given a _positive_ number `n`.
+
+Return the **smallest** number `x` **greater than** or **equal to** `n`, such that the binary representation of `x` contains only **set** bits.
+
+A **set** bit refers to a bit in the binary representation of a number that has a value of `1`.
+
+**Example 1:**
+
+**Input:** n = 5
+
+**Output:** 7
+
+**Explanation:**
+
+The binary representation of 7 is `"111"`.
+
+**Example 2:**
+
+**Input:** n = 10
+
+**Output:** 15
+
+**Explanation:**
+
+The binary representation of 15 is `"1111"`.
+
+**Example 3:**
+
+**Input:** n = 3
+
+**Output:** 3
+
+**Explanation:**
+
+The binary representation of 3 is `"11"`.
+
+**Constraints:**
+
+*   `1 <= n <= 1000`

src/main/kotlin/g3301_3400/s3371_identify_the_largest_outlier_in_an_array/Solution.kt

@@ -0,0 +1,30 @@
+package g3301_3400.s3371_identify_the_largest_outlier_in_an_array
+
+// #Medium #Array #Hash_Table #Counting #Enumeration
+// #2024_12_03_Time_5_ms_(100.00%)_Space_60.6_MB_(33.40%)
+
+class Solution {
+    fun getLargestOutlier(nums: IntArray): Int {
+        val cnt = IntArray(2001)
+        var sum = 0
+        for (i in nums) {
+            sum += i
+            cnt[i + 1000]++
+        }
+        for (i in cnt.indices.reversed()) {
+            val j = i - 1000
+            if (cnt[i] == 0) {
+                continue
+            }
+            sum -= j
+            val csum = (sum shr 1) + 1000
+            cnt[i]--
+            if (sum % 2 == 0 && csum >= 0 && csum < cnt.size && cnt[csum] > 0) {
+                return j
+            }
+            sum += j
+            cnt[i]++
+        }
+        return 0
+    }
+}

src/main/kotlin/g3301_3400/s3371_identify_the_largest_outlier_in_an_array/readme.md

@@ -0,0 +1,47 @@
+3371\. Identify the Largest Outlier in an Array
+
+Medium
+
+You are given an integer array `nums`. This array contains `n` elements, where **exactly** `n - 2` elements are **special** **numbers**. One of the remaining **two** elements is the _sum_ of these **special numbers**, and the other is an **outlier**.
+
+An **outlier** is defined as a number that is _neither_ one of the original special numbers _nor_ the element representing the sum of those numbers.
+
+**Note** that special numbers, the sum element, and the outlier must have **distinct** indices, but _may_ share the **same** value.
+
+Return the **largest** potential **outlier** in `nums`.
+
+**Example 1:**
+
+**Input:** nums = [2,3,5,10]
+
+**Output:** 10
+
+**Explanation:**
+
+The special numbers could be 2 and 3, thus making their sum 5 and the outlier 10.
+
+**Example 2:**
+
+**Input:** nums = [-2,-1,-3,-6,4]
+
+**Output:** 4
+
+**Explanation:**
+
+The special numbers could be -2, -1, and -3, thus making their sum -6 and the outlier 4.
+
+**Example 3:**
+
+**Input:** nums = [1,1,1,1,1,5,5]
+
+**Output:** 5
+
+**Explanation:**
+
+The special numbers could be 1, 1, 1, 1, and 1, thus making their sum 5 and the other 5 as the outlier.
+
+**Constraints:**
+
+*   <code>3 <= nums.length <= 10<sup>5</sup></code>
+*   `-1000 <= nums[i] <= 1000`
+*   The input is generated such that at least **one** potential outlier exists in `nums`.

src/main/kotlin/g3301_3400/s3372_maximize_the_number_of_target_nodes_after_connecting_trees_i/Solution.kt

@@ -0,0 +1,97 @@
+package g3301_3400.s3372_maximize_the_number_of_target_nodes_after_connecting_trees_i
+
+// #Medium #Tree #Depth_First_Search #Breadth_First_Search
+// #2024_12_03_Time_50_ms_(99.49%)_Space_75.7_MB_(5.10%)
+
+import kotlin.math.max
+
+class Solution {
+    private fun getGraph(edges: Array<IntArray>): Array<ArrayList<Int?>?> {
+        val n = edges.size + 1
+        val graph: Array<ArrayList<Int?>?> = arrayOfNulls<ArrayList<Int?>?>(n)
+        for (i in 0..<n) {
+            graph[i] = ArrayList<Int?>()
+        }
+        for (edge in edges) {
+            val u = edge[0]
+            val v = edge[1]
+            graph[u]!!.add(v)
+            graph[v]!!.add(u)
+        }
+        return graph
+    }
+
+    private fun dfs(graph: Array<ArrayList<Int?>?>, u: Int, pt: Int, dp: Array<IntArray?>, k: Int) {
+        for (v in graph[u]!!) {
+            if (v == pt) {
+                continue
+            }
+            dfs(graph, v!!, u, dp, k)
+            for (i in 0..<k) {
+                dp[u]!![i + 1] += dp[v]!![i]
+            }
+        }
+        dp[u]!![0] = dp[u]!![0] + 1
+    }
+
+    private fun dfs2(
+        graph: Array<ArrayList<Int?>?>,
+        u: Int,
+        pt: Int,
+        ptv: IntArray,
+        fdp: Array<IntArray?>,
+        dp: Array<IntArray?>,
+        k: Int,
+    ) {
+        fdp[u]!![0] = dp[u]!![0]
+        for (i in 1..k) {
+            fdp[u]!![i] = (dp[u]!![i] + ptv[i - 1])
+        }
+        for (v in graph[u]!!) {
+            if (v == pt) {
+                continue
+            }
+            val nptv = IntArray(k + 1)
+            for (i in 0..<k) {
+                nptv[i + 1] = dp[u]!![i + 1] - dp[v!!]!![i] + ptv[i]
+            }
+            nptv[0] = 1
+            dfs2(graph, v!!, u, nptv, fdp, dp, k)
+        }
+    }
+
+    private fun get(edges: Array<IntArray>, k: Int): Array<IntArray?> {
+        val graph = getGraph(edges)
+        val n = graph.size
+        val dp = Array<IntArray?>(n) { IntArray(k + 1) }
+        val fdp = Array<IntArray?>(n) { IntArray(k + 1) }
+        dfs(graph, 0, -1, dp, k)
+        dfs2(graph, 0, -1, IntArray(k + 1), fdp, dp, k)
+        for (i in 0..<n) {
+            for (j in 1..k) {
+                fdp[i]!![j] += fdp[i]!![j - 1]
+            }
+        }
+        return fdp
+    }
+
+    fun maxTargetNodes(edges1: Array<IntArray>, edges2: Array<IntArray>, k: Int): IntArray {
+        val a = get(edges1, k)
+        val b = get(edges2, k)
+        val n = a.size
+        val m = b.size
+        val ans = IntArray(n)
+        var max = 0
+        run {
+            var i = 0
+            while (k != 0 && i < m) {
+                max = max(max.toDouble(), b[i]!![k - 1].toDouble()).toInt()
+                i++
+            }
+        }
+        for (i in 0..<n) {
+            ans[i] = a[i]!![k] + max
+        }
+        return ans
+    }
+}

src/main/kotlin/g3301_3400/s3372_maximize_the_number_of_target_nodes_after_connecting_trees_i/readme.md

@@ -0,0 +1,54 @@
+3372\. Maximize the Number of Target Nodes After Connecting Trees I
+
+Medium
+
+There exist two **undirected** trees with `n` and `m` nodes, with **distinct** labels in ranges `[0, n - 1]` and `[0, m - 1]`, respectively.
+
+You are given two 2D integer arrays `edges1` and `edges2` of lengths `n - 1` and `m - 1`, 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. You are also given an integer `k`.
+
+Node `u` is **target** to node `v` if the number of edges on the path from `u` to `v` is less than or equal to `k`. **Note** that a node is _always_ **target** to itself.
+
+Return an array of `n` integers `answer`, where `answer[i]` is the **maximum** possible number of nodes **target** to node `i` of the first tree if you have to connect one node from the first tree to another node in the second tree.
+
+**Note** that queries are independent from each other. That is, for every query you will remove the added edge before proceeding to the next query.
+
+**Example 1:**
+
+**Input:** edges1 = [[0,1],[0,2],[2,3],[2,4]], edges2 = [[0,1],[0,2],[0,3],[2,7],[1,4],[4,5],[4,6]], k = 2
+
+**Output:** [9,7,9,8,8]
+
+**Explanation:**
+
+*   For `i = 0`, connect node 0 from the first tree to node 0 from the second tree.
+*   For `i = 1`, connect node 1 from the first tree to node 0 from the second tree.
+*   For `i = 2`, connect node 2 from the first tree to node 4 from the second tree.
+*   For `i = 3`, connect node 3 from the first tree to node 4 from the second tree.
+*   For `i = 4`, connect node 4 from the first tree to node 4 from the second tree.
+
+![](https://assets.leetcode.com/uploads/2024/09/24/3982-1.png)
+
+**Example 2:**
+
+**Input:** edges1 = [[0,1],[0,2],[0,3],[0,4]], edges2 = [[0,1],[1,2],[2,3]], k = 1
+
+**Output:** [6,3,3,3,3]
+
+**Explanation:**
+
+For every `i`, connect node `i` of the first tree with any node of the second tree.
+
+![](https://assets.leetcode.com/uploads/2024/09/24/3928-2.png)
+
+**Constraints:**
+
+*   `2 <= n, m <= 1000`
+*   `edges1.length == n - 1`
+*   `edges2.length == m - 1`
+*   `edges1[i].length == edges2[i].length == 2`
+*   <code>edges1[i] = [a<sub>i</sub>, b<sub>i</sub>]</code>
+*   <code>0 <= a<sub>i</sub>, b<sub>i</sub> < n</code>
+*   <code>edges2[i] = [u<sub>i</sub>, v<sub>i</sub>]</code>
+*   <code>0 <= u<sub>i</sub>, v<sub>i</sub> < m</code>
+*   The input is generated such that `edges1` and `edges2` represent valid trees.
+*   `0 <= k <= 1000`

src/main/kotlin/g3301_3400/s3373_maximize_the_number_of_target_nodes_after_connecting_trees_ii/Solution.kt

@@ -0,0 +1,72 @@
+package g3301_3400.s3373_maximize_the_number_of_target_nodes_after_connecting_trees_ii
+
+// #Hard #Tree #Depth_First_Search #Breadth_First_Search
+// #2024_12_03_Time_26_ms_(98.75%)_Space_114.7_MB_(80.00%)
+
+import kotlin.math.max
+
+class Solution {
+    fun maxTargetNodes(edges1: Array<IntArray>, edges2: Array<IntArray>): IntArray {
+        val n = edges1.size + 1
+        val g1 = packU(n, edges1)
+        val m = edges2.size + 1
+        val g2 = packU(m, edges2)
+        val p2 = parents(g2)
+        val eo2 = IntArray(2)
+        for (i in 0..<m) {
+            eo2[p2[2]!![i] % 2]++
+        }
+        val max = max(eo2[0], eo2[1])
+        val p1 = parents(g1)
+        val eo1 = IntArray(2)
+        for (i in 0..<n) {
+            eo1[p1[2]!![i] % 2]++
+        }
+        val ans = IntArray(n)
+        for (i in 0..<n) {
+            ans[i] = eo1[p1[2]!![i] % 2] + max
+        }
+        return ans
+    }
+
+    private fun parents(g: Array<IntArray?>): Array<IntArray?> {
+        val n = g.size
+        val par = IntArray(n)
+        par.fill(-1)
+        val depth = IntArray(n)
+        depth[0] = 0
+        val q = IntArray(n)
+        q[0] = 0
+        var p = 0
+        var r = 1
+        while (p < r) {
+            val cur = q[p]
+            for (nex in g[cur]!!) {
+                if (par[cur] != nex) {
+                    q[r++] = nex
+                    par[nex] = cur
+                    depth[nex] = depth[cur] + 1
+                }
+            }
+            p++
+        }
+        return arrayOf<IntArray?>(par, q, depth)
+    }
+
+    private fun packU(n: Int, ft: Array<IntArray>): Array<IntArray?> {
+        val g = arrayOfNulls<IntArray>(n)
+        val p = IntArray(n)
+        for (u in ft) {
+            p[u[0]]++
+            p[u[1]]++
+        }
+        for (i in 0..<n) {
+            g[i] = IntArray(p[i])
+        }
+        for (u in ft) {
+            g[u[0]]!![--p[u[0]]] = u[1]
+            g[u[1]]!![--p[u[1]]] = u[0]
+        }
+        return g
+    }
+}