Added tasks 3370-3373

Author: javadev

src/main/java/g3301_3400/s3370_smallest_number_with_all_set_bits/Solution.java

@@ -0,0 +1,13 @@
+package g3301_3400.s3370_smallest_number_with_all_set_bits;
+
+// #Easy #2024_12_01_Time_0_ms_(100.00%)_Space_40.7_MB_(100.00%)
+
+public class Solution {
+    public int smallestNumber(int n) {
+        int res = 1;
+        while (res < n) {
+            res = res * 2 + 1;
+        }
+        return res;
+    }
+}

src/main/java/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/java/g3301_3400/s3371_identify_the_largest_outlier_in_an_array/Solution.java

@@ -0,0 +1,33 @@
+package g3301_3400.s3371_identify_the_largest_outlier_in_an_array;
+
+// #Medium #2024_12_01_Time_633_ms_(100.00%)_Space_64.5_MB_(100.00%)
+
+import java.util.TreeMap;
+
+public class Solution {
+    public int getLargestOutlier(int[] nums) {
+        int sum = 0;
+        for (int num : nums) {
+            sum += num;
+        }
+        TreeMap<Integer, Integer> frequencyMap = new TreeMap<>();
+        for (int num : nums) {
+            frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);
+        }
+        int ans = Integer.MIN_VALUE;
+        for (int num : nums) {
+            if ((sum - num) % 2 == 0) {
+                int target = (sum - num) / 2;
+                frequencyMap.put(num, frequencyMap.get(num) - 1);
+                if (frequencyMap.get(num) == 0) {
+                    frequencyMap.remove(num);
+                }
+                if (frequencyMap.containsKey(target)) {
+                    ans = Math.max(ans, num);
+                }
+                frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);
+            }
+        }
+        return ans == Integer.MIN_VALUE ? -1 : ans;
+    }
+}

src/main/java/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/java/g3301_3400/s3372_maximize_the_number_of_target_nodes_after_connecting_trees_i/Solution.java

@@ -0,0 +1,68 @@
+package g3301_3400.s3372_maximize_the_number_of_target_nodes_after_connecting_trees_i;
+
+// #Medium #2024_12_01_Time_828_ms_(100.00%)_Space_47.8_MB_(100.00%)
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class Solution {
+    private void bfs(ArrayList<ArrayList<Integer>> tree, int node, int[] arr, int k) {
+        Queue<Integer> q = new LinkedList<>();
+        HashSet<Integer> visited = new HashSet<>();
+        q.add(node);
+        int count = 0;
+        while (!q.isEmpty() && count <= k) {
+            int size = q.size();
+            for (int i = 0; i < size; i++) {
+                int temp = q.poll();
+                visited.add(temp);
+                for (int x : tree.get(temp)) {
+                    if (!visited.contains(x)) {
+                        q.offer(x);
+                    }
+                }
+            }
+            count++;
+        }
+        arr[node] = visited.size();
+    }
+
+    public int[] maxTargetNodes(int[][] edges1, int[][] edges2, int k) {
+        int n = edges1.length + 1;
+        int m = edges2.length + 1;
+        ArrayList<ArrayList<Integer>> tree1 = new ArrayList<>();
+        ArrayList<ArrayList<Integer>> tree2 = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            tree1.add(new ArrayList<>());
+        }
+        for (int i = 0; i < m; i++) {
+            tree2.add(new ArrayList<>());
+        }
+        for (int[] e : edges1) {
+            tree1.get(e[0]).add(e[1]);
+            tree1.get(e[1]).add(e[0]);
+        }
+        for (int[] e : edges2) {
+            tree2.get(e[0]).add(e[1]);
+            tree2.get(e[1]).add(e[0]);
+        }
+        int[] tar1 = new int[n];
+        int[] tar2 = new int[m];
+        for (int i = 0; i < m; i++) {
+            bfs(tree2, i, tar2, k - 1);
+        }
+        int max = 0;
+        for (int i : tar2) {
+            max = Math.max(i, max);
+        }
+        for (int i = 0; i < n; i++) {
+            bfs(tree1, i, tar1, k);
+        }
+        for (int i = 0; i < n; i++) {
+            tar1[i] += max;
+        }
+        return tar1;
+    }
+}

src/main/java/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/java/g3301_3400/s3373_maximize_the_number_of_target_nodes_after_connecting_trees_ii/Solution.java

@@ -0,0 +1,85 @@
+package g3301_3400.s3373_maximize_the_number_of_target_nodes_after_connecting_trees_ii;
+
+// #Hard #2024_12_01_Time_447_ms_(100.00%)_Space_173.2_MB_(100.00%)
+
+import java.util.HashMap;
+import java.util.HashSet;
+
+public class Solution {
+    private int dfs(int a, HashMap<Integer, HashSet<Integer>> adj, boolean[] mark, int i) {
+        int res = 0;
+        mark[a] = true;
+        if (i % 2 == 0) {
+            res++;
+        }
+        for (int j : adj.get(a)) {
+            if (!mark[j]) {
+                res += dfs(j, adj, mark, i + 1);
+            }
+        }
+        return res;
+    }
+
+    private void sol(
+            int a,
+            HashMap<Integer, HashSet<Integer>> adj,
+            boolean[] mark,
+            int i,
+            int t,
+            int n,
+            int[] res) {
+        mark[a] = true;
+        if (i % 2 == 0) {
+            res[a] = t;
+        } else {
+            res[a] = n - t;
+        }
+        for (int j : adj.get(a)) {
+            if (!mark[j]) {
+                sol(j, adj, mark, i + 1, t, n, res);
+            }
+        }
+    }
+
+    public int[] maxTargetNodes(int[][] edges1, int[][] edges2) {
+        int n = edges1.length + 1;
+        int m = edges2.length + 1;
+        HashMap<Integer, HashSet<Integer>> adj1 = new HashMap<>();
+        HashMap<Integer, HashSet<Integer>> adj2 = new HashMap<>();
+        for (int[] i : edges1) {
+            if (adj1.get(i[0]) == null) {
+                adj1.put(i[0], new HashSet<>());
+            }
+            adj1.get(i[0]).add(i[1]);
+            if (adj1.get(i[1]) == null) {
+                adj1.put(i[1], new HashSet<>());
+            }
+            adj1.get(i[1]).add(i[0]);
+        }
+        for (int[] i : edges2) {
+            if (adj2.get(i[0]) == null) {
+                adj2.put(i[0], new HashSet<>());
+            }
+            adj2.get(i[0]).add(i[1]);
+            if (adj2.get(i[1]) == null) {
+                adj2.put(i[1], new HashSet<>());
+            }
+            adj2.get(i[1]).add(i[0]);
+        }
+        boolean[] mark1 = new boolean[n];
+        boolean[] mark2 = new boolean[m];
+        int a = dfs(0, adj2, mark2, 0);
+        int b = dfs(0, adj1, mark1, 0);
+        mark1 = new boolean[n];
+        int[] res = new int[n];
+        sol(0, adj1, mark1, 0, b, n, res);
+        for (int i = 0; i < res.length; i++) {
+            if (res[i] != n) {
+                res[i] += Math.max(a, m - a);
+            } else {
+                res[i] += a;
+            }
+        }
+        return res;
+    }
+}