Added tasks 2384, 2385.

Author: javadev

README.md

@@ -1848,6 +1848,8 @@ implementation 'com.github.javadev:leetcode-in-java:1.12'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2385 |[Amount of Time for Binary Tree to Be Infected](src/main/java/g2301_2400/s2385_amount_of_time_for_binary_tree_to_be_infected/Solution.java)| Medium | Tree, Binary_Tree, Depth_First_Search, Breadth_First_Search | 20 | 100.00
+| 2384 |[Largest Palindromic Number](src/main/java/g2301_2400/s2384_largest_palindromic_number/Solution.java)| Medium | String, Hash_Table, Greedy | 26 | 100.00
 | 2383 |[Minimum Hours of Training to Win a Competition](src/main/java/g2301_2400/s2383_minimum_hours_of_training_to_win_a_competition/Solution.java)| Easy | Array, Greedy | 0 | 100.00
 | 2382 |[Maximum Segment Sum After Removals](src/main/java/g2301_2400/s2382_maximum_segment_sum_after_removals/Solution.java)| Hard | Array, Prefix_Sum, Union_Find, Ordered_Set | 28 | 100.00
 | 2381 |[Shifting Letters II](src/main/java/g2301_2400/s2381_shifting_letters_ii/Solution.java)| Medium | Array, String, Prefix_Sum | 10 | 75.00

src/main/java/g2301_2400/s2384_largest_palindromic_number/Solution.java

@@ -0,0 +1,35 @@
+package g2301_2400.s2384_largest_palindromic_number;
+
+// #Medium #String #Hash_Table #Greedy #2022_08_25_Time_26_ms_(100.00%)_Space_54.8_MB_(100.00%)
+
+public class Solution {
+    public String largestPalindromic(String num) {
+        int[] count = new int[10];
+        int center = -1;
+        StringBuilder first = new StringBuilder();
+        StringBuilder second;
+        for (char c : num.toCharArray()) {
+            count[c - '0']++;
+        }
+        int c = 0;
+        for (int i = 9; i >= 0; i--) {
+            c = 0;
+            if (count[i] % 2 == 1 && center == -1) {
+                center = i;
+            }
+            if (first.length() == 0 && i == 0) {
+                continue;
+            }
+            while (c < count[i] / 2) {
+                first.append(String.valueOf(i));
+                c++;
+            }
+        }
+        second = new StringBuilder(first.toString());
+        if (center != -1) {
+            first.append(center);
+        }
+        first.append(second.reverse().toString());
+        return first.length() == 0 ? "0" : first.toString();
+    }
+}

src/main/java/g2301_2400/s2384_largest_palindromic_number/readme.md

@@ -0,0 +1,41 @@
+2384\. Largest Palindromic Number
+
+Medium
+
+You are given a string `num` consisting of digits only.
+
+Return _the **largest palindromic** integer (in the form of a string) that can be formed using digits taken from_ `num`. It should not contain **leading zeroes**.
+
+**Notes:**
+
+*   You do **not** need to use all the digits of `num`, but you must use **at least** one digit.
+*   The digits can be reordered.
+
+**Example 1:**
+
+**Input:** num = "444947137"
+
+**Output:** "7449447"
+
+**Explanation:**
+
+Use the digits "4449477" from "<ins>**44494**</ins><ins>**7**</ins>13<ins>**7**</ins>" to form the palindromic integer "7449447".
+
+It can be shown that "7449447" is the largest palindromic integer that can be formed.
+
+**Example 2:**
+
+**Input:** num = "00009"
+
+**Output:** "9"
+
+**Explanation:**
+
+It can be shown that "9" is the largest palindromic integer that can be formed.
+
+Note that the integer returned should not contain leading zeroes.
+
+**Constraints:**
+
+*   <code>1 <= num.length <= 10<sup>5</sup></code>
+*   `num` consists of digits.

src/main/java/g2301_2400/s2385_amount_of_time_for_binary_tree_to_be_infected/Solution.java

@@ -0,0 +1,60 @@
+package g2301_2400.s2385_amount_of_time_for_binary_tree_to_be_infected;
+
+// #Medium #Tree #Binary_Tree #Depth_First_Search #Breadth_First_Search
+// #2022_08_25_Time_20_ms_(100.00%)_Space_111.7_MB_(100.00%)
+
+import com_github_leetcode.TreeNode;
+
+/*
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+public class Solution {
+    private int max = 0;
+
+    public int amountOfTime(TreeNode root, int start) {
+        dfs(root, start, new Distance(-1));
+        return max;
+    }
+
+    private int dfs(TreeNode root, int start, Distance l) {
+        if (root == null) {
+            return 0;
+        }
+        Distance ld = new Distance(-1);
+        Distance rd = new Distance(-1);
+        int left = dfs(root.left, start, ld);
+        int right = dfs(root.right, start, rd);
+        if (l.val == -1 && start == root.val) {
+            max = Math.max(left, right);
+            l.val = 1;
+        }
+        if (ld.val != -1) {
+            max = Math.max(max, ld.val + right);
+            l.val = ld.val + 1;
+        } else if (rd.val != -1) {
+            max = Math.max(max, rd.val + left);
+            l.val = rd.val + 1;
+        }
+        return Math.max(left, right) + 1;
+    }
+
+    private static class Distance {
+        int val;
+
+        Distance(int v) {
+            this.val = v;
+        }
+    }
+}

src/main/java/g2301_2400/s2385_amount_of_time_for_binary_tree_to_be_infected/readme.md

@@ -0,0 +1,51 @@
+2385\. Amount of Time for Binary Tree to Be Infected
+
+Medium
+
+You are given the `root` of a binary tree with **unique** values, and an integer `start`. At minute `0`, an **infection** starts from the node with value `start`.
+
+Each minute, a node becomes infected if:
+
+*   The node is currently uninfected.
+*   The node is adjacent to an infected node.
+
+Return _the number of minutes needed for the entire tree to be infected._
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/06/25/image-20220625231744-1.png)
+
+**Input:** root = [1,5,3,null,4,10,6,9,2], start = 3
+
+**Output:** 4
+
+**Explanation:** The following nodes are infected during:
+
+- Minute 0: Node 3
+
+- Minute 1: Nodes 1, 10 and 6
+
+- Minute 2: Node 5
+
+- Minute 3: Node 4
+
+- Minute 4: Nodes 9 and 2
+
+It takes 4 minutes for the whole tree to be infected so we return 4. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/06/25/image-20220625231812-2.png)
+
+**Input:** root = [1], start = 1
+
+**Output:** 0
+
+**Explanation:** At minute 0, the only node in the tree is infected so we return 0. 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[1, 10<sup>5</sup>]</code>.
+*   <code>1 <= Node.val <= 10<sup>5</sup></code>
+*   Each node has a **unique** value.
+*   A node with a value of `start` exists in the tree.

src/test/java/g2301_2400/s2384_largest_palindromic_number/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2301_2400.s2384_largest_palindromic_number;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void largestPalindromic() {
+        assertThat(new Solution().largestPalindromic("444947137"), equalTo("7449447"));
+    }
+
+    @Test
+    void largestPalindromic2() {
+        assertThat(new Solution().largestPalindromic("00009"), equalTo("9"));
+    }
+}

src/test/java/g2301_2400/s2385_amount_of_time_for_binary_tree_to_be_infected/SolutionTest.java

@@ -0,0 +1,33 @@
+package g2301_2400.s2385_amount_of_time_for_binary_tree_to_be_infected;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com_github_leetcode.TreeNode;
+import java.util.Arrays;
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void amountOfTime() {
+        assertThat(
+                new Solution()
+                        .amountOfTime(
+                                TreeNode.create(Arrays.asList(1, 5, 3, null, 4, 10, 6, 9, 2)), 3),
+                equalTo(4));
+    }
+
+    @Test
+    void amountOfTime2() {
+        assertThat(new Solution().amountOfTime(TreeNode.create(Arrays.asList(1)), 1), equalTo(0));
+    }
+
+    @Test
+    void amountOfTime3() {
+        assertThat(
+                new Solution()
+                        .amountOfTime(
+                                TreeNode.create(Arrays.asList(1, 2, null, 3, null, 4, null, 5)), 4),
+                equalTo(3));
+    }
+}