Added tasks 2470, 2471, 2472, 2475, 2476

Author: ThanhNIT

README.md

@@ -1848,6 +1848,11 @@ implementation 'com.github.javadev:leetcode-in-java:1.17'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2476 |[Closest Nodes Queries in a Binary Search Tree](src/main/java/g2401_2500/s2476_closest_nodes_queries_in_a_binary_search_tree/Solution.java)| Medium | Array, Tree, Binary_Search, Binary_Tree, Depth_First_Search | 185 | 51.92
+| 2475 |[Number of Unequal Triplets in Array](src/main/java/g2401_2500/s2475_number_of_unequal_triplets_in_array/Solution.java)| Easy | Array, Hash_Table | 1 | 97.49
+| 2472 |[Maximum Number of Non-overlapping Palindrome Substrings](src/main/java/g2401_2500/s2472_maximum_number_of_non_overlapping_palindrome_substrings/Solution.java)| Hard | String, Dynamic_Programming | 2 | 91.04
+| 2471 |[Minimum Number of Operations to Sort a Binary Tree by Level](src/main/java/g2401_2500/s2471_minimum_number_of_operations_to_sort_a_binary_tree_by_level/Solution.java)| Medium | Tree, Binary_Tree, Breadth_First_Search | 76 | 76.46
+| 2470 |[Number of Subarrays With LCM Equal to K](src/main/java/g2401_2500/s2470_number_of_subarrays_with_lcm_equal_to_k/Solution.java)| Medium | Array, Math, Number_Theory | 23 | 62.35
 | 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

src/main/java/g2401_2500/s2470_number_of_subarrays_with_lcm_equal_to_k/Solution.java

@@ -0,0 +1,26 @@
+package g2401_2500.s2470_number_of_subarrays_with_lcm_equal_to_k;
+
+// #Medium #Array #Math #Number_Theory #2023_01_24_Time_23_ms_(62.35%)_Space_41.9_MB_(63.16%)
+
+public class Solution {
+    public int subarrayLCM(int[] nums, int k) {
+        int ans = 0;
+        for (int i = 0; i < nums.length; i++) {
+            int lcm = nums[i];
+            for (int j = i; j < nums.length; j++) {
+                lcm = (lcm * nums[j]) / (gcd(lcm, nums[j]));
+                if (lcm == k) {
+                    ans++;
+                }
+                if (k % lcm != 0) {
+                    break;
+                }
+            }
+        }
+        return ans;
+    }
+
+    private int gcd(int a, int b) {
+        return b == 0 ? a : gcd(b, a % b);
+    }
+}

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

@@ -0,0 +1,34 @@
+2470\. Number of Subarrays With LCM Equal to K
+
+Medium
+
+Given an integer array `nums` and an integer `k`, return _the number of **subarrays** of_ `nums` _where the least common multiple of the subarray's elements is_ `k`.
+
+A **subarray** is a contiguous non-empty sequence of elements within an array.
+
+The **least common multiple of an array** is the smallest positive integer that is divisible by all the array elements.
+
+**Example 1:**
+
+**Input:** nums = [3,6,2,7,1], k = 6
+
+**Output:** 4
+
+**Explanation:** The subarrays of nums where 6 is the least common multiple of all the subarray's elements are:
+- [<ins>**3**</ins>,<ins>**6**</ins>,2,7,1] 
+- [<ins>**3**</ins>,<ins>**6**</ins>,<ins>**2**</ins>,7,1] 
+- [3,<ins>**6**</ins>,2,7,1] 
+- [3,<ins>**6**</ins>,<ins>**2**</ins>,7,1]
+
+**Example 2:**
+
+**Input:** nums = [3], k = 2
+
+**Output:** 0
+
+**Explanation:** There are no subarrays of nums where 2 is the least common multiple of all the subarray's elements.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   `1 <= nums[i], k <= 1000`

src/main/java/g2401_2500/s2471_minimum_number_of_operations_to_sort_a_binary_tree_by_level/Solution.java

@@ -0,0 +1,68 @@
+package g2401_2500.s2471_minimum_number_of_operations_to_sort_a_binary_tree_by_level;
+
+// #Medium #Tree #Binary_Tree #Breadth_First_Search
+// #2023_01_24_Time_76_ms_(76.46%)_Space_66_MB_(63.11%)
+
+import com_github_leetcode.TreeNode;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Solution {
+    public int minimumOperations(TreeNode root) {
+        ArrayDeque<TreeNode> q = new ArrayDeque<>();
+        int count = 0;
+        if ((root.left != null && root.right != null) && (root.left.val > root.right.val)) {
+            count++;
+        }
+        if (root.left != null) {
+            q.add(root.left);
+        }
+        if (root.right != null) {
+            q.add(root.right);
+        }
+        while (!q.isEmpty()) {
+            int size = q.size();
+            List<Integer> al = new ArrayList<>();
+            while (size-- > 0) {
+                TreeNode node = q.poll();
+                assert node != null;
+                if (node.left != null) {
+                    al.add(node.left.val);
+                    q.add(node.left);
+                }
+                if (node.right != null) {
+                    al.add(node.right.val);
+                    q.add(node.right);
+                }
+            }
+            count += helper(al);
+        }
+        return count;
+    }
+
+    private int helper(List<Integer> list) {
+        int swaps = 0;
+        int[] sorted = new int[list.size()];
+        for (int i = 0; i < sorted.length; i++) {
+            sorted[i] = list.get(i);
+        }
+        Arrays.sort(sorted);
+        Map<Integer, Integer> ind = new HashMap<>();
+        for (int i = 0; i < list.size(); i++) {
+            ind.put(list.get(i), i);
+        }
+
+        for (int i = 0; i < list.size(); i++) {
+            if (list.get(i) != sorted[i]) {
+                swaps++;
+                ind.put(list.get(i), ind.get(sorted[i]));
+                list.set(ind.get(sorted[i]), list.get(i));
+            }
+        }
+        return swaps;
+    }
+}

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

@@ -0,0 +1,57 @@
+2471\. Minimum Number of Operations to Sort a Binary Tree by Level
+
+Medium
+
+You are given the `root` of a binary tree with **unique values**.
+
+In one operation, you can choose any two nodes **at the same level** and swap their values.
+
+Return _the minimum number of operations needed to make the values at each level sorted in a **strictly increasing order**_.
+
+The **level** of a node is the number of edges along the path between it and the root node_._
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/09/18/image-20220918174006-2.png)
+
+**Input:** root = [1,4,3,7,6,8,5,null,null,null,null,9,null,10]
+
+**Output:** 3
+
+**Explanation:**
+- Swap 4 and 3. The 2<sup>nd</sup> level becomes [3,4]. 
+- Swap 7 and 5. The 3<sup>rd</sup> level becomes [5,6,8,7]. 
+- Swap 8 and 7. The 3<sup>rd</sup> level becomes [5,6,7,8]. 
+
+We used 3 operations so return 3. It can be proven that 3 is the minimum number of operations needed.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/09/18/image-20220918174026-3.png)
+
+**Input:** root = [1,3,2,7,6,5,4]
+
+**Output:** 3
+
+**Explanation:** 
+- Swap 3 and 2. The 2<sup>nd</sup> level becomes [2,3].
+- Swap 7 and 4. The 3<sup>rd</sup> level becomes [4,6,5,7]. 
+- Swap 6 and 5. The 3<sup>rd</sup> level becomes [4,5,6,7]. 
+
+We used 3 operations so return 3. It can be proven that 3 is the minimum number of operations needed.
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2022/09/18/image-20220918174052-4.png)
+
+**Input:** root = [1,2,3,4,5,6]
+
+**Output:** 0
+
+**Explanation:** Each level is already sorted in increasing order so 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>
+*   All the values of the tree are **unique**.

src/main/java/g2401_2500/s2472_maximum_number_of_non_overlapping_palindrome_substrings/Solution.java

@@ -0,0 +1,42 @@
+package g2401_2500.s2472_maximum_number_of_non_overlapping_palindrome_substrings;
+
+// #Hard #String #Dynamic_Programming #2023_01_24_Time_2_ms_(91.04%)_Space_42.2_MB_(64.93%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int maxPalindromes(String s, int k) {
+        int[] dp = new int[s.length()];
+        Arrays.fill(dp, -1);
+        return dfs(s, dp, k, 0);
+    }
+
+    private int dfs(String s, int[] dp, int k, int start) {
+        if (start >= s.length()) {
+            return 0;
+        }
+        if (dp[start] != -1) {
+            return dp[start];
+        }
+        int ans = 0;
+        for (int n = 0; n <= 1; n++) {
+            for (int i = start; i <= s.length() - k - n; i++) {
+                int left = i;
+                int right = i + k + n - 1;
+                while (left < right) {
+                    if (s.charAt(left) != s.charAt(right)) {
+                        break;
+                    }
+                    left++;
+                    right--;
+                }
+                if (left >= right) {
+                    ans = Math.max(ans, 1 + dfs(s, dp, k, i + k + n));
+                    break;
+                }
+            }
+        }
+        dp[start] = ans;
+        return ans;
+    }
+}

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

@@ -0,0 +1,35 @@
+2472\. Maximum Number of Non-overlapping Palindrome Substrings
+
+Hard
+
+You are given a string `s` and a **positive** integer `k`.
+
+Select a set of **non-overlapping** substrings from the string `s` that satisfy the following conditions:
+
+*   The **length** of each substring is **at least** `k`.
+*   Each substring is a **palindrome**.
+
+Return _the **maximum** number of substrings in an optimal selection_.
+
+A **substring** is a contiguous sequence of characters within a string.
+
+**Example 1:**
+
+**Input:** s = "abaccdbbd", k = 3
+
+**Output:** 2
+
+**Explanation:** We can select the substrings underlined in s = "<ins>**aba**</ins>cc<ins>**dbbd**</ins>". Both "aba" and "dbbd" are palindromes and have a length of at least k = 3. It can be shown that we cannot find a selection with more than two valid substrings.
+
+**Example 2:**
+
+**Input:** s = "adbcda", k = 2
+
+**Output:** 0
+
+**Explanation:** There is no palindrome substring of length at least 2 in the string.
+
+**Constraints:**
+
+*   `1 <= k <= s.length <= 2000`
+*   `s` consists of lowercase English letters.

src/main/java/g2401_2500/s2475_number_of_unequal_triplets_in_array/Solution.java

@@ -0,0 +1,17 @@
+package g2401_2500.s2475_number_of_unequal_triplets_in_array;
+
+// #Easy #Array #Hash_Table #2023_01_24_Time_1_ms_(97.49%)_Space_40.3_MB_(57.72%)
+
+public class Solution {
+    public int unequalTriplets(int[] nums) {
+        int trips = 0;
+        int pairs = 0;
+        int[] count = new int[1001];
+        for (int i = 0; i < nums.length; ++i) {
+            trips += pairs - count[nums[i]] * (i - count[nums[i]]);
+            pairs += i - count[nums[i]];
+            count[nums[i]] += 1;
+        }
+        return trips;
+    }
+}

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

@@ -0,0 +1,38 @@
+2475\. Number of Unequal Triplets in Array
+
+Easy
+
+You are given a **0-indexed** array of positive integers `nums`. Find the number of triplets `(i, j, k)` that meet the following conditions:
+
+*   `0 <= i < j < k < nums.length`
+*   `nums[i]`, `nums[j]`, and `nums[k]` are **pairwise distinct**.
+    *   In other words, `nums[i] != nums[j]`, `nums[i] != nums[k]`, and `nums[j] != nums[k]`.
+
+Return _the number of triplets that meet the conditions._
+
+**Example 1:**
+
+**Input:** nums = [4,4,2,4,3]
+
+**Output:** 3
+
+**Explanation:** The following triplets meet the conditions: 
+
+- (0, 2, 4) because 4 != 2 != 3
+- (1, 2, 4) because 4 != 2 != 3
+- (2, 3, 4) because 2 != 4 != 3
+Since there are 3 triplets, we return 3. 
+Note that (2, 0, 4) is not a valid triplet because 2 > 0.
+
+**Example 2:**
+
+**Input:** nums = [1,1,1,1,1]
+
+**Output:** 0
+
+**Explanation:** No triplets meet the conditions so we return 0.
+
+**Constraints:**
+
+*   `3 <= nums.length <= 100`
+*   `1 <= nums[i] <= 1000`