Added tasks 2466, 2467, 2468, 2469.

Author: javadev

README.md

@@ -1848,6 +1848,10 @@ implementation 'com.github.javadev:leetcode-in-java:1.17'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2469 |[Convert the Temperature](src/main/java/g2401_2500/s2469_convert_the_temperature/Solution.java)| Easy | Math | 0 | 100.00
+| 2468 |[Split Message Based on Limit](src/main/java/g2401_2500/s2468_split_message_based_on_limit/Solution.java)| Hard | String, Binary_Search | 27 | 99.08
+| 2467 |[Most Profitable Path in a Tree](src/main/java/g2401_2500/s2467_most_profitable_path_in_a_tree/Solution.java)| Medium | Array, Tree, Graph, Depth_First_Search, Breadth_First_Search | 20 | 100.00
+| 2466 |[Count Ways To Build Good Strings](src/main/java/g2401_2500/s2466_count_ways_to_build_good_strings/Solution.java)| Medium | Dynamic_Programming | 8 | 99.59
 | 2465 |[Number of Distinct Averages](src/main/java/g2401_2500/s2465_number_of_distinct_averages/Solution.java)| Easy | Array, Hash_Table, Sorting, Two_Pointers | 1 | 99.48
 | 2463 |[Minimum Total Distance Traveled](src/main/java/g2401_2500/s2463_minimum_total_distance_traveled/Solution.java)| Hard | Array, Dynamic_Programming, Sorting | 2 | 100.00
 | 2462 |[Total Cost to Hire K Workers](src/main/java/g2401_2500/s2462_total_cost_to_hire_k_workers/Solution.java)| Medium | Array, Two_Pointers, Heap_Priority_Queue, Simulation | 57 | 96.24

src/main/java/g2401_2500/s2466_count_ways_to_build_good_strings/Solution.java

@@ -0,0 +1,29 @@
+package g2401_2500.s2466_count_ways_to_build_good_strings;
+
+// #Medium #Dynamic_Programming #2023_01_11_Time_8_ms_(99.59%)_Space_41_MB_(98.19%)
+
+public class Solution {
+    public int countGoodStrings(int low, int high, int zero, int one) {
+        int[] dp = new int[high + 1];
+        dp[zero]++;
+        dp[one]++;
+        int ans = 0;
+        for (int i = 0; i < high + 1; i++) {
+            if (dp[i] != 0) {
+                if (i + zero <= high) {
+                    dp[i + zero] += dp[i];
+                    dp[i + zero] = dp[i + zero] % 1000000007;
+                }
+                if (i + one <= high) {
+                    dp[i + one] += dp[i];
+                    dp[i + one] = dp[i + one] % 1000000007;
+                }
+                if (i >= low) {
+                    ans += dp[i];
+                    ans = ans % 1000000007;
+                }
+            }
+        }
+        return ans;
+    }
+}

src/main/java/g2401_2500/s2466_count_ways_to_build_good_strings/readme.md

@@ -0,0 +1,41 @@
+2466\. Count Ways To Build Good Strings
+
+Medium
+
+Given the integers `zero`, `one`, `low`, and `high`, we can construct a string by starting with an empty string, and then at each step perform either of the following:
+
+*   Append the character `'0'` `zero` times.
+*   Append the character `'1'` `one` times.
+
+This can be performed any number of times.
+
+A **good** string is a string constructed by the above process having a **length** between `low` and `high` (**inclusive**).
+
+Return _the number of **different** good strings that can be constructed satisfying these properties._ Since the answer can be large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** low = 3, high = 3, zero = 1, one = 1
+
+**Output:** 8
+
+**Explanation:**
+
+One possible valid good string is "011".
+
+It can be constructed as follows: "" -> "0" -> "01" -> "011".
+
+All binary strings from "000" to "111" are good strings in this example. 
+
+**Example 2:**
+
+**Input:** low = 2, high = 3, zero = 1, one = 2
+
+**Output:** 5
+
+**Explanation:** The good strings are "00", "11", "000", "110", and "011". 
+
+**Constraints:**
+
+*   <code>1 <= low <= high <= 10<sup>5</sup></code>
+*   `1 <= zero, one <= low`

src/main/java/g2401_2500/s2467_most_profitable_path_in_a_tree/Solution.java

@@ -0,0 +1,80 @@
+package g2401_2500.s2467_most_profitable_path_in_a_tree;
+
+// #Medium #Array #Tree #Graph #Depth_First_Search #Breadth_First_Search
+// #2023_01_11_Time_20_ms_(100.00%)_Space_94_MB_(96.10%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int mostProfitablePath(int[][] edges, int bob, int[] amount) {
+        int n = amount.length;
+        int[][] g = packU(n, edges);
+        int[][] pars = parents(g, 0);
+        int[] par = pars[0];
+        int[] ord = pars[1];
+        int[] dep = pars[2];
+        int u = bob;
+        for (int i = 0; i < (dep[bob] + 1) / 2; i++) {
+            amount[u] = 0;
+            u = par[u];
+        }
+        if (dep[bob] % 2 == 0) {
+            amount[u] /= 2;
+        }
+        int[] dp = new int[n];
+        for (int i = n - 1; i >= 0; i--) {
+            int cur = ord[i];
+            if (g[cur].length == 1 && i > 0) {
+                dp[cur] = amount[cur];
+            } else {
+                dp[cur] = Integer.MIN_VALUE / 2;
+                for (int e : g[cur]) {
+                    if (par[cur] == e) {
+                        continue;
+                    }
+                    dp[cur] = Math.max(dp[cur], dp[e] + amount[cur]);
+                }
+            }
+        }
+        return dp[0];
+    }
+
+    private int[][] parents(int[][] g, int root) {
+        int n = g.length;
+        int[] par = new int[n];
+        Arrays.fill(par, -1);
+        int[] depth = new int[n];
+        depth[0] = 0;
+        int[] q = new int[n];
+        q[0] = root;
+        int r = 1;
+        for (int p = 0; p < r; p++) {
+            int cur = q[p];
+            for (int nex : g[cur]) {
+                if (par[cur] != nex) {
+                    q[r++] = nex;
+                    par[nex] = cur;
+                    depth[nex] = depth[cur] + 1;
+                }
+            }
+        }
+        return new int[][] {par, q, depth};
+    }
+
+    private int[][] packU(int n, int[][] ft) {
+        int[][] g = new int[n][];
+        int[] p = new int[n];
+        for (int[] u : ft) {
+            p[u[0]]++;
+            p[u[1]]++;
+        }
+        for (int i = 0; i < n; i++) {
+            g[i] = new int[p[i]];
+        }
+        for (int[] u : ft) {
+            g[u[0]][--p[u[0]]] = u[1];
+            g[u[1]][--p[u[1]]] = u[0];
+        }
+        return g;
+    }
+}

src/main/java/g2401_2500/s2467_most_profitable_path_in_a_tree/readme.md

@@ -0,0 +1,79 @@
+2467\. Most Profitable Path in a Tree
+
+Medium
+
+There is an undirected tree with `n` nodes labeled from `0` to `n - 1`, rooted at node `0`. You are given a 2D integer array `edges` of length `n - 1` where <code>edges[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 tree.
+
+At every node `i`, there is a gate. You are also given an array of even integers `amount`, where `amount[i]` represents:
+
+*   the price needed to open the gate at node `i`, if `amount[i]` is negative, or,
+*   the cash reward obtained on opening the gate at node `i`, otherwise.
+
+The game goes on as follows:
+
+*   Initially, Alice is at node `0` and Bob is at node `bob`.
+*   At every second, Alice and Bob **each** move to an adjacent node. Alice moves towards some **leaf node**, while Bob moves towards node `0`.
+*   For **every** node along their path, Alice and Bob either spend money to open the gate at that node, or accept the reward. Note that:
+    *   If the gate is **already open**, no price will be required, nor will there be any cash reward.
+    *   If Alice and Bob reach the node **simultaneously**, they share the price/reward for opening the gate there. In other words, if the price to open the gate is `c`, then both Alice and Bob pay `c / 2` each. Similarly, if the reward at the gate is `c`, both of them receive `c / 2` each.
+*   If Alice reaches a leaf node, she stops moving. Similarly, if Bob reaches node `0`, he stops moving. Note that these events are **independent** of each other.
+
+Return _the **maximum** net income Alice can have if she travels towards the optimal leaf node._
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/10/29/eg1.png)
+
+**Input:** edges = [[0,1],[1,2],[1,3],[3,4]], bob = 3, amount = [-2,4,2,-4,6]
+
+**Output:** 6
+
+**Explanation:**
+
+The above diagram represents the given tree. The game goes as follows:
+
+- Alice is initially on node 0, Bob on node 3. They open the gates of their respective nodes.
+
+Alice's net income is now -2.
+
+- Both Alice and Bob move to node 1.
+
+Since they reach here simultaneously, they open the gate together and share the reward.
+
+Alice's net income becomes -2 + (4 / 2) = 0.
+
+- Alice moves on to node 3. Since Bob already opened its gate, Alice's income remains unchanged.
+
+Bob moves on to node 0, and stops moving.
+
+- Alice moves on to node 4 and opens the gate there. Her net income becomes 0 + 6 = 6.
+
+Now, neither Alice nor Bob can make any further moves, and the game ends.
+
+It is not possible for Alice to get a higher net income. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/10/29/eg2.png)
+
+**Input:** edges = [[0,1]], bob = 1, amount = [-7280,2350]
+
+**Output:** -7280
+
+**Explanation:**
+
+Alice follows the path 0->1 whereas Bob follows the path 1->0.
+
+Thus, Alice opens the gate at node 0 only. Hence, her net income is -7280. 
+
+**Constraints:**
+
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   `edges.length == n - 1`
+*   `edges[i].length == 2`
+*   <code>0 <= a<sub>i</sub>, b<sub>i</sub> < n</code>
+*   <code>a<sub>i</sub> != b<sub>i</sub></code>
+*   `edges` represents a valid tree.
+*   `1 <= bob < n`
+*   `amount.length == n`
+*   `amount[i]` is an **even** integer in the range <code>[-10<sup>4</sup>, 10<sup>4</sup>]</code>.

src/main/java/g2401_2500/s2468_split_message_based_on_limit/Solution.java

@@ -0,0 +1,59 @@
+package g2401_2500.s2468_split_message_based_on_limit;
+
+// #Hard #String #Binary_Search #2023_01_11_Time_27_ms_(99.08%)_Space_50.2_MB_(94.85%)
+
+@SuppressWarnings("java:S3518")
+public class Solution {
+    public String[] splitMessage(String message, int limit) {
+        int total = 0;
+        int running = 0;
+        int count;
+        int totalReq;
+        int valUsed = -1;
+        int minLimitReq;
+        for (int i = 1; i <= message.length(); ++i) {
+            count = getCount(i);
+            running += count;
+            total = running + (count * i) + 3 * i;
+            totalReq = total + message.length();
+            minLimitReq = (totalReq + i - 1) / i;
+            if (minLimitReq <= limit) {
+                valUsed = i;
+                break;
+            }
+        }
+        if (valUsed == -1) {
+            return new String[] {};
+        }
+        StringBuilder sb = new StringBuilder();
+        int idx = 0;
+        StringBuilder sb2 = new StringBuilder();
+        int left;
+        String[] result = new String[valUsed];
+        for (int i = 1; i <= valUsed; ++i) {
+            sb2.setLength(0);
+            sb.setLength(0);
+            sb2.append('<');
+            sb2.append(i);
+            sb2.append('/');
+            sb2.append(valUsed);
+            sb2.append('>');
+            left = limit - sb2.length();
+            while (idx < message.length() && left-- > 0) {
+                sb.append(message.charAt(idx++));
+            }
+            sb.append(sb2);
+            result[i - 1] = sb.toString();
+        }
+        return result;
+    }
+
+    private int getCount(int val) {
+        int result = 0;
+        while (val != 0) {
+            val /= 10;
+            ++result;
+        }
+        return result;
+    }
+}

src/main/java/g2401_2500/s2468_split_message_based_on_limit/readme.md

@@ -0,0 +1,47 @@
+2468\. Split Message Based on Limit
+
+Hard
+
+You are given a string, `message`, and a positive integer, `limit`.
+
+You must **split** `message` into one or more **parts** based on `limit`. Each resulting part should have the suffix `"<a/b>"`, where `"b"` is to be **replaced** with the total number of parts and `"a"` is to be **replaced** with the index of the part, starting from `1` and going up to `b`. Additionally, the length of each resulting part (including its suffix) should be **equal** to `limit`, except for the last part whose length can be **at most** `limit`.
+
+The resulting parts should be formed such that when their suffixes are removed and they are all concatenated **in order**, they should be equal to `message`. Also, the result should contain as few parts as possible.
+
+Return _the parts_ `message` _would be split into as an array of strings_. If it is impossible to split `message` as required, return _an empty array_.
+
+**Example 1:**
+
+**Input:** message = "this is really a very awesome message", limit = 9
+
+**Output:** ["thi<1/14>","s i<2/14>","s r<3/14>","eal<4/14>","ly <5/14>","a v<6/14>","ery<7/14>"," aw<8/14>","eso<9/14>","me<10/14>"," m<11/14>","es<12/14>","sa<13/14>","ge<14/14>"]
+
+**Explanation:**
+
+The first 9 parts take 3 characters each from the beginning of message.
+
+The next 5 parts take 2 characters each to finish splitting message.
+
+In this example, each part, including the last, has length 9.
+
+It can be shown it is not possible to split message into less than 14 parts. 
+
+**Example 2:**
+
+**Input:** message = "short message", limit = 15
+
+**Output:** ["short mess<1/2>","age<2/2>"]
+
+**Explanation:**
+
+Under the given constraints, the string can be split into two parts:
+
+- The first part comprises of the first 10 characters, and has a length 15.
+
+- The next part comprises of the last 3 characters, and has a length 8. 
+
+**Constraints:**
+
+*   <code>1 <= message.length <= 10<sup>4</sup></code>
+*   `message` consists only of lowercase English letters and `' '`.
+*   <code>1 <= limit <= 10<sup>4</sup></code>

src/main/java/g2401_2500/s2469_convert_the_temperature/Solution.java

@@ -0,0 +1,14 @@
+package g2401_2500.s2469_convert_the_temperature;
+
+// #Easy #Math #2023_01_11_Time_0_ms_(100.00%)_Space_40.6_MB_(87.87%)
+
+public class Solution {
+    public double[] convertTemperature(double celsius) {
+        double kelvin = celsius + 273.15;
+        double fahrenheit = celsius * 1.80 + 32.00;
+        double[] arr = new double[2];
+        arr[0] = kelvin;
+        arr[1] = fahrenheit;
+        return arr;
+    }
+}