Added tasks 2490, 2491, 2492, 2493, 2496

Author: ThanhNIT

README.md

@@ -1848,6 +1848,11 @@ implementation 'com.github.javadev:leetcode-in-java:1.17'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2496 |[Maximum Value of a String in an Array](src/main/java/g2401_2500/s2496_maximum_value_of_a_string_in_an_array/Solution.java)| Easy | Array, String | 1 | 92.00
+| 2493 |[Divide Nodes Into the Maximum Number of Groups](src/main/java/g2401_2500/s2493_divide_nodes_into_the_maximum_number_of_groups/Solution.java)| Hard | Graph, Union_Find, Breadth_First_Search | 443 | 77.02
+| 2492 |[Minimum Score of a Path Between Two Cities](src/main/java/g2401_2500/s2492_minimum_score_of_a_path_between_two_cities/Solution.java)| Medium | Graph, Union_Find, Depth_First_Search, Breadth_First_Search | 13 | 92.82
+| 2491 |[Divide Players Into Teams of Equal Skill](src/main/java/g2401_2500/s2491_divide_players_into_teams_of_equal_skill/Solution.java)| Medium | Array, Hash_Table, Sorting, Two_Pointers | 21 | 70.31
+| 2490 |[Circular Sentence](src/main/java/g2401_2500/s2490_circular_sentence/Solution.java)| Easy | String | 1 | 99.85
 | 2488 |[Count Subarrays With Median K](src/main/java/g2401_2500/s2488_count_subarrays_with_median_k/Solution.java)| Hard | Array, Hash_Table, Prefix_Sum | 24 | 72.25
 | 2487 |[Remove Nodes From Linked List](src/main/java/g2401_2500/s2487_remove_nodes_from_linked_list/Solution.java)| Medium | Stack, Linked_List, Monotonic_Stack, Recursion | 5 | 99.79
 | 2486 |[Append Characters to String to Make Subsequence](src/main/java/g2401_2500/s2486_append_characters_to_string_to_make_subsequence/Solution.java)| Medium | String, Greedy, Two_Pointers | 2 | 99.89

src/main/java/g2401_2500/s2490_circular_sentence/Solution.java

@@ -0,0 +1,16 @@
+package g2401_2500.s2490_circular_sentence;
+
+// #Easy #String #2023_01_27_Time_1_ms_(99.85%)_Space_42.6_MB_(55.63%)
+
+public class Solution {
+    public boolean isCircularSentence(String sentence) {
+        char[] letters = sentence.toCharArray();
+        int len = letters.length;
+        for (int i = 0; i < len - 1; ++i) {
+            if (letters[i] == ' ' && letters[i - 1] != letters[i + 1]) {
+                return false;
+            }
+        }
+        return letters[0] == letters[len - 1];
+    }
+}

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

@@ -0,0 +1,56 @@
+2490\. Circular Sentence
+
+Easy
+
+A **sentence** is a list of words that are separated by a **single** space with no leading or trailing spaces.
+
+*   For example, `"Hello World"`, `"HELLO"`, `"hello world hello world"` are all sentences.
+
+Words consist of **only** uppercase and lowercase English letters. Uppercase and lowercase English letters are considered different.
+
+A sentence is **circular** if:
+
+*   The last character of a word is equal to the first character of the next word.
+*   The last character of the last word is equal to the first character of the first word.
+
+For example, `"leetcode exercises sound delightful"`, `"eetcode"`, `"leetcode eats soul"` are all circular sentences. However, `"Leetcode is cool"`, `"happy Leetcode"`, `"Leetcode"` and `"I like Leetcode"` are **not** circular sentences.
+
+Given a string `sentence`, return `true` _if it is circular_. Otherwise, return `false`.
+
+**Example 1:**
+
+**Input:** sentence = "leetcode exercises sound delightful"
+
+**Output:** true
+
+**Explanation:** The words in sentence are ["leetcode", "exercises", "sound", "delightful"].
+- leetcod<ins>e</ins>'s last character is equal to <ins>e</ins>xercises's first character. 
+- exercise<ins>s</ins>'s last character is equal to <ins>s</ins>ound's first character. 
+- soun<ins>d</ins>'s last character is equal to <ins>d</ins>elightful's first character. 
+- delightfu<ins>l</ins>'s last character is equal to <ins>l</ins>eetcode's first character. 
+
+The sentence is circular.
+
+**Example 2:**
+
+**Input:** sentence = "eetcode"
+
+**Output:** true
+
+**Explanation:** The words in sentence are ["eetcode"].
+- eetcod<ins>e</ins>'s last character is equal to <ins>e</ins>etcode's first character. The sentence is circular.
+
+**Example 3:**
+
+**Input:** sentence = "Leetcode is cool"
+
+**Output:** false
+
+**Explanation:** The words in sentence are ["Leetcode", "is", "cool"]. - Leetcod<ins>e</ins>'s last character is **not** equal to <ins>i</ins>s's first character. The sentence is **not** circular.
+
+**Constraints:**
+
+*   `1 <= sentence.length <= 500`
+*   `sentence` consist of only lowercase and uppercase English letters and spaces.
+*   The words in `sentence` are separated by a single space.
+*   There are no leading or trailing spaces.

src/main/java/g2401_2500/s2491_divide_players_into_teams_of_equal_skill/Solution.java

@@ -0,0 +1,25 @@
+package g2401_2500.s2491_divide_players_into_teams_of_equal_skill;
+
+// #Medium #Array #Hash_Table #Sorting #Two_Pointers
+// #2023_01_27_Time_21_ms_(70.31%)_Space_73.6_MB_(27.92%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public long dividePlayers(int[] skill) {
+        int i = 0;
+        int j = skill.length - 1;
+        Arrays.sort(skill);
+        int sum = skill[i] + skill[j];
+        long p = 0;
+        while (i < j) {
+            if (skill[i] + skill[j] != sum) {
+                return -1;
+            }
+            p += ((long) skill[i] * skill[j]);
+            i++;
+            j--;
+        }
+        return p;
+    }
+}

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

@@ -0,0 +1,39 @@
+2491\. Divide Players Into Teams of Equal Skill
+
+Medium
+
+You are given a positive integer array `skill` of **even** length `n` where `skill[i]` denotes the skill of the <code>i<sup>th</sup></code> player. Divide the players into `n / 2` teams of size `2` such that the total skill of each team is **equal**.
+
+The **chemistry** of a team is equal to the **product** of the skills of the players on that team.
+
+Return _the sum of the **chemistry** of all the teams, or return_ `-1` _if there is no way to divide the players into teams such that the total skill of each team is equal._
+
+**Example 1:**
+
+**Input:** skill = [3,2,5,1,3,4]
+
+**Output:** 22
+
+**Explanation:** Divide the players into the following teams: (1, 5), (2, 4), (3, 3), where each team has a total skill of 6. The sum of the chemistry of all the teams is: 1 \* 5 + 2 \* 4 + 3 \* 3 = 5 + 8 + 9 = 22.
+
+**Example 2:**
+
+**Input:** skill = [3,4]
+
+**Output:** 12
+
+**Explanation:** The two players form a team with a total skill of 7. The chemistry of the team is 3 \* 4 = 12.
+
+**Example 3:**
+
+**Input:** skill = [1,1,2,3]
+
+**Output:** -1
+
+**Explanation:** There is no way to divide the players into teams such that the total skill of each team is equal.
+
+**Constraints:**
+
+*   <code>2 <= skill.length <= 10<sup>5</sup></code>
+*   `skill.length` is even.
+*   `1 <= skill[i] <= 1000`

src/main/java/g2401_2500/s2492_minimum_score_of_a_path_between_two_cities/Solution.java

@@ -0,0 +1,30 @@
+package g2401_2500.s2492_minimum_score_of_a_path_between_two_cities;
+
+// #Medium #Graph #Union_Find #Depth_First_Search #Breadth_First_Search
+// #2023_01_27_Time_13_ms_(92.82%)_Space_101.5_MB_(78.71%)
+
+import java.util.Arrays;
+
+public class Solution {
+    private int[] dsu;
+
+    public int minScore(int n, int[][] roads) {
+        dsu = new int[n + 1];
+        int[] ans = new int[n + 1];
+        for (int i = 0; i <= n; i++) {
+            dsu[i] = i;
+        }
+        Arrays.fill(ans, Integer.MAX_VALUE);
+        for (int[] r : roads) {
+            int a = find(r[0]);
+            int b = find(r[1]);
+            dsu[a] = dsu[b];
+            ans[a] = ans[b] = Math.min(r[2], Math.min(ans[a], ans[b]));
+        }
+        return ans[find(1)];
+    }
+
+    private int find(int i) {
+        return dsu[i] == i ? i : find(dsu[i]);
+    }
+}

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

@@ -0,0 +1,46 @@
+2492\. Minimum Score of a Path Between Two Cities
+
+Medium
+
+You are given a positive integer `n` representing `n` cities numbered from `1` to `n`. You are also given a **2D** array `roads` where <code>roads[i] = [a<sub>i</sub>, b<sub>i</sub>, distance<sub>i</sub>]</code> indicates that there is a **bidirectional** road between cities <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code> with a distance equal to <code>distance<sub>i</sub></code>. The cities graph is not necessarily connected.
+
+The **score** of a path between two cities is defined as the **minimum** distance of a road in this path.
+
+Return _the **minimum** possible score of a path between cities_ `1` _and_ `n`.
+
+**Note**:
+
+*   A path is a sequence of roads between two cities.
+*   It is allowed for a path to contain the same road **multiple** times, and you can visit cities `1` and `n` multiple times along the path.
+*   The test cases are generated such that there is **at least** one path between `1` and `n`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/10/12/graph11.png)
+
+**Input:** n = 4, roads = [[1,2,9],[2,3,6],[2,4,5],[1,4,7]]
+
+**Output:** 5
+
+**Explanation:** The path from city 1 to 4 with the minimum score is: 1 -> 2 -> 4. The score of this path is min(9,5) = 5. It can be shown that no other path has less score.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/10/12/graph22.png)
+
+**Input:** n = 4, roads = [[1,2,2],[1,3,4],[3,4,7]]
+
+**Output:** 2
+
+**Explanation:** The path from city 1 to 4 with the minimum score is: 1 -> 2 -> 1 -> 3 -> 4. The score of this path is min(2,2,4,7) = 2.
+
+**Constraints:**
+
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   <code>1 <= roads.length <= 10<sup>5</sup></code>
+*   `roads[i].length == 3`
+*   <code>1 <= a<sub>i</sub>, b<sub>i</sub> <= n</code>
+*   <code>a<sub>i</sub> != b<sub>i</sub></code>
+*   <code>1 <= distance<sub>i</sub> <= 10<sup>4</sup></code>
+*   There are no repeated edges.
+*   There is at least one path between `1` and `n`.

src/main/java/g2401_2500/s2493_divide_nodes_into_the_maximum_number_of_groups/Solution.java

@@ -0,0 +1,66 @@
+package g2401_2500.s2493_divide_nodes_into_the_maximum_number_of_groups;
+
+// #Hard #Graph #Union_Find #Breadth_First_Search
+// #2023_01_27_Time_443_ms_(77.02%)_Space_47.8_MB_(77.54%)
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+public class Solution {
+    public int magnificentSets(int n, int[][] edges) {
+        List<List<Integer>> adj = new ArrayList<>();
+        int[] visited = new int[n + 1];
+        Arrays.fill(visited, -1);
+        for (int i = 0; i <= n; i++) {
+            adj.add(new ArrayList<>());
+        }
+        for (int[] edge : edges) {
+            adj.get(edge[0]).add(edge[1]);
+            adj.get(edge[1]).add(edge[0]);
+        }
+        int[] comp = new int[n + 1];
+        int count = -1;
+        int ans = 0;
+        for (int i = 1; i <= n; i++) {
+            if (visited[i] == -1) {
+                count++;
+                comp[count] = bfs(i, adj, visited, count, n);
+                if (comp[count] == -1) {
+                    return -1;
+                }
+            } else {
+                comp[visited[i]] = Math.max(comp[visited[i]], bfs(i, adj, visited, visited[i], n));
+            }
+        }
+        for (int group : comp) {
+            ans += group;
+        }
+        return ans;
+    }
+
+    private int bfs(int start, List<List<Integer>> adj, int[] visited, int count, int n) {
+        Queue<Integer> q = new LinkedList<>();
+        visited[start] = count;
+        int ans = 1;
+        int[] group = new int[n + 1];
+        q.add(start);
+        group[start] = 1;
+        while (!q.isEmpty()) {
+            int node = q.remove();
+            for (int adjN : adj.get(node)) {
+                if (group[adjN] == 0) {
+                    visited[adjN] = count;
+                    group[adjN] = group[node] + 1;
+                    q.add(adjN);
+                    ans = Math.max(ans, group[adjN]);
+                } else if (Math.abs(group[adjN] - group[node]) != 1) {
+                    return -1;
+                }
+            }
+        }
+        return ans;
+    }
+}

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

@@ -0,0 +1,47 @@
+2493\. Divide Nodes Into the Maximum Number of Groups
+
+Hard
+
+You are given a positive integer `n` representing the number of nodes in an **undirected** graph. The nodes are labeled from `1` to `n`.
+
+You are also given a 2D integer array `edges`, where <code>edges[i] = [a<sub>i,</sub> b<sub>i</sub>]</code> indicates that there is a **bidirectional** edge between nodes <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code>. **Notice** that the given graph may be disconnected.
+
+Divide the nodes of the graph into `m` groups (**1-indexed**) such that:
+
+*   Each node in the graph belongs to exactly one group.
+*   For every pair of nodes in the graph that are connected by an edge <code>[a<sub>i,</sub> b<sub>i</sub>]</code>, if <code>a<sub>i</sub></code> belongs to the group with index `x`, and <code>b<sub>i</sub></code> belongs to the group with index `y`, then `|y - x| = 1`.
+
+Return _the maximum number of groups (i.e., maximum_ `m`_) into which you can divide the nodes_. Return `-1` _if it is impossible to group the nodes with the given conditions_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/10/13/example1.png)
+
+**Input:** n = 6, edges = [[1,2],[1,4],[1,5],[2,6],[2,3],[4,6]]
+
+**Output:** 4
+
+**Explanation:** As shown in the image we:
+- Add node 5 to the first group. 
+- Add node 1 to the second group. 
+- Add nodes 2 and 4 to the third group. 
+- Add nodes 3 and 6 to the fourth group.
+
+We can see that every edge is satisfied. It can be shown that that if we create a fifth group and move any node from the third or fourth group to it, at least on of the edges will not be satisfied.
+
+**Example 2:**
+
+**Input:** n = 3, edges = [[1,2],[2,3],[3,1]]
+
+**Output:** -1
+
+**Explanation:** If we add node 1 to the first group, node 2 to the second group, and node 3 to the third group to satisfy the first two edges, we can see that the third edge will not be satisfied. It can be shown that no grouping is possible.
+
+**Constraints:**
+
+*   `1 <= n <= 500`
+*   <code>1 <= edges.length <= 10<sup>4</sup></code>
+*   `edges[i].length == 2`
+*   <code>1 <= a<sub>i</sub>, b<sub>i</sub> <= n</code>
+*   <code>a<sub>i</sub> != b<sub>i</sub></code>
+*   There is at most one edge between any pair of vertices.

src/main/java/g2401_2500/s2496_maximum_value_of_a_string_in_an_array/Solution.java

@@ -0,0 +1,25 @@
+package g2401_2500.s2496_maximum_value_of_a_string_in_an_array;
+
+// #Easy #Array #String #2023_01_27_Time_1_ms_(92.00%)_Space_41.7_MB_(54.56%)
+
+public class Solution {
+    public int maximumValue(String[] strs) {
+        int maxVal = 0;
+        for (String s : strs) {
+            maxVal = Math.max(maxVal, value(s));
+        }
+        return maxVal;
+    }
+
+    private int value(String s) {
+        int total = 0;
+        for (char ch : s.toCharArray()) {
+            if (ch >= '0' && ch <= '9') {
+                total = total * 10 + (ch - '0');
+            } else {
+                return s.length();
+            }
+        }
+        return total;
+    }
+}