Added tasks 2045, 2047, 2048, 2049, 2050.

Author: ThanhNIT

src/main/java/g2001_2100/s2045_second_minimum_time_to_reach_destination/Solution.java

@@ -0,0 +1,66 @@
+package g2001_2100.s2045_second_minimum_time_to_reach_destination;
+
+// #Hard #Breadth_First_Search #Graph #Shortest_Path
+// #2022_05_26_Time_65_ms_(74.03%)_Space_51.6_MB_(97.24%)
+
+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 secondMinimum(int n, int[][] edges, int time, int change) {
+        List<Integer>[] adj = new ArrayList[n];
+        for (int i = 0; i < adj.length; i++) {
+            adj[i] = new ArrayList<>();
+        }
+        for (int[] edge : edges) {
+            int p = edge[0] - 1;
+            int q = edge[1] - 1;
+            adj[p].add(q);
+            adj[q].add(p);
+        }
+        int[] dis1 = new int[n];
+        int[] dis2 = new int[n];
+
+        Arrays.fill(dis1, Integer.MAX_VALUE);
+        Arrays.fill(dis2, Integer.MAX_VALUE);
+        dis1[0] = 0;
+        Queue<int[]> queue = new LinkedList<>();
+        queue.offer(new int[] {0, 0});
+        while (!queue.isEmpty()) {
+            int[] temp = queue.poll();
+            int cur = temp[0];
+            int path = temp[1];
+
+            for (int node : adj[cur]) {
+                int newPath = path + 1;
+                if (newPath < dis1[node]) {
+                    dis2[node] = dis1[node];
+                    dis1[node] = newPath;
+                    queue.offer(new int[] {node, newPath});
+                } else if ((newPath > dis1[node]) && (newPath < dis2[node])) {
+                    dis2[node] = newPath;
+                    queue.offer(new int[] {node, newPath});
+                }
+            }
+        }
+        return helper(dis2[n - 1], time, change);
+    }
+
+    private int helper(int pathValue, int time, int change) {
+        int sum = 0;
+        for (int i = 0; i < pathValue; i++) {
+            sum += time;
+            if (i == pathValue - 1) {
+                break;
+            }
+            if ((sum / change) % 2 == 0) {
+                continue;
+            }
+            sum = (sum / change + 1) * change;
+        }
+        return sum;
+    }
+}

src/main/java/g2001_2100/s2045_second_minimum_time_to_reach_destination/readme.md

@@ -0,0 +1,81 @@
+2045\. Second Minimum Time to Reach Destination
+
+Hard
+
+A city is represented as a **bi-directional connected** graph with `n` vertices where each vertex is labeled from `1` to `n` (**inclusive**). The edges in the graph are represented as a 2D integer array `edges`, where each <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>]</code> denotes a bi-directional edge between vertex <code>u<sub>i</sub></code> and vertex <code>v<sub>i</sub></code>. Every vertex pair is connected by **at most one** edge, and no vertex has an edge to itself. The time taken to traverse any edge is `time` minutes.
+
+Each vertex has a traffic signal which changes its color from **green** to **red** and vice versa every `change` minutes. All signals change **at the same time**. You can enter a vertex at **any time**, but can leave a vertex **only when the signal is green**. You **cannot wait** at a vertex if the signal is **green**.
+
+The **second minimum value** is defined as the smallest value **strictly larger** than the minimum value.
+
+*   For example the second minimum value of `[2, 3, 4]` is `3`, and the second minimum value of `[2, 2, 4]` is `4`.
+
+Given `n`, `edges`, `time`, and `change`, return _the **second minimum time** it will take to go from vertex_ `1` _to vertex_ `n`.
+
+**Notes:**
+
+*   You can go through any vertex **any** number of times, **including** `1` and `n`.
+*   You can assume that when the journey **starts**, all signals have just turned **green**.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/09/29/e1.png)         ![](https://assets.leetcode.com/uploads/2021/09/29/e2.png)
+
+**Input:** n = 5, edges = [[1,2],[1,3],[1,4],[3,4],[4,5]], time = 3, change = 5
+
+**Output:** 13
+
+**Explanation:** 
+
+The figure on the left shows the given graph.
+
+The blue path in the figure on the right is the minimum time path. 
+
+The time taken is: 
+
+- Start at 1, time elapsed=0 
+
+- 1 -> 4: 3 minutes, time elapsed=3 
+
+- 4 -> 5: 3 minutes, time elapsed=6 
+  
+Hence the minimum time needed is 6 minutes. 
+
+The red path shows the path to get the second minimum time. 
+
+- Start at 1, time elapsed=0 
+
+- 1 -> 3: 3 minutes, time elapsed=3 
+
+- 3 -> 4: 3 minutes, time elapsed=6 
+
+- Wait at 4 for 4 minutes, time elapsed=10 
+
+- 4 -> 5: 3 minutes, time elapsed=13 
+  
+Hence the second minimum time is 13 minutes.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/09/29/eg2.png)
+
+**Input:** n = 2, edges = [[1,2]], time = 3, change = 2
+
+**Output:** 11
+
+**Explanation:** 
+
+The minimum time path is 1 -> 2 with time = 3 minutes. 
+
+The second minimum time path is 1 -> 2 -> 1 -> 2 with time = 11 minutes.
+
+**Constraints:**
+
+*   <code>2 <= n <= 10<sup>4</sup></code>
+*   <code>n - 1 <= edges.length <= min(2 * 10<sup>4</sup>, n * (n - 1) / 2)</code>
+*   `edges[i].length == 2`
+*   <code>1 <= u<sub>i</sub>, v<sub>i</sub> <= n</code>
+*   <code>u<sub>i</sub> != v<sub>i</sub></code>
+*   There are no duplicate edges.
+*   Each vertex can be reached directly or indirectly from every other vertex.
+*   <code>1 <= time, change <= 10<sup>3</sup></code>

src/main/java/g2001_2100/s2047_number_of_valid_words_in_a_sentence/Solution.java

@@ -0,0 +1,46 @@
+package g2001_2100.s2047_number_of_valid_words_in_a_sentence;
+
+// #Easy #String #2022_05_26_Time_19_ms_(42.57%)_Space_44.9_MB_(37.62%)
+
+public class Solution {
+    public int countValidWords(String sentence) {
+        String[] tokens = sentence.split("\\s+");
+        int count = 0;
+        for (String token : tokens) {
+            int hyphenCount = 0;
+            int punctuationMarkCount = 0;
+            boolean valid = true;
+            if (token.isEmpty() || token.equals("") || token.length() == 0) {
+                continue;
+            }
+            for (int i = 0; i < token.length(); i++) {
+                if (token.charAt(i) == '-') {
+                    hyphenCount++;
+                    if (hyphenCount > 1
+                            || i == 0
+                            || i == token.length() - 1
+                            || !Character.isAlphabetic(token.charAt(i - 1))
+                            || !Character.isAlphabetic(token.charAt(i + 1))) {
+                        valid = false;
+                        break;
+                    }
+                } else if (token.charAt(i) == '!'
+                        || token.charAt(i) == '.'
+                        || token.charAt(i) == ',') {
+                    punctuationMarkCount++;
+                    if (punctuationMarkCount > 1 || i != token.length() - 1) {
+                        valid = false;
+                        break;
+                    }
+                } else if (Character.isDigit(token.charAt(i))) {
+                    valid = false;
+                    break;
+                }
+            }
+            if (valid) {
+                count++;
+            }
+        }
+        return count;
+    }
+}

src/main/java/g2001_2100/s2047_number_of_valid_words_in_a_sentence/readme.md

@@ -0,0 +1,49 @@
+2047\. Number of Valid Words in a Sentence
+
+Easy
+
+A sentence consists of lowercase letters (`'a'` to `'z'`), digits (`'0'` to `'9'`), hyphens (`'-'`), punctuation marks (`'!'`, `'.'`, and `','`), and spaces (`' '`) only. Each sentence can be broken down into **one or more tokens** separated by one or more spaces `' '`.
+
+A token is a valid word if **all three** of the following are true:
+
+*   It only contains lowercase letters, hyphens, and/or punctuation (**no** digits).
+*   There is **at most one** hyphen `'-'`. If present, it **must** be surrounded by lowercase characters (`"a-b"` is valid, but `"-ab"` and `"ab-"` are not valid).
+*   There is **at most one** punctuation mark. If present, it **must** be at the **end** of the token (`"ab,"`, `"cd!"`, and `"."` are valid, but `"a!b"` and `"c.,"` are not valid).
+
+Examples of valid words include `"a-b."`, `"afad"`, `"ba-c"`, `"a!"`, and `"!"`.
+
+Given a string `sentence`, return _the **number** of valid words in_ `sentence`.
+
+**Example 1:**
+
+**Input:** sentence = "cat and dog"
+
+**Output:** 3
+
+**Explanation:** The valid words in the sentence are "cat", "and", and "dog".
+
+**Example 2:**
+
+**Input:** sentence = "!this 1-s b8d!"
+
+**Output:** 0
+
+**Explanation:** There are no valid words in the sentence. 
+
+"!this" is invalid because it starts with a punctuation mark. 
+
+"1-s" and "b8d" are invalid because they contain digits.
+
+**Example 3:**
+
+**Input:** sentence = "alice and bob are playing stone-game10"
+
+**Output:** 5
+
+**Explanation:** The valid words in the sentence are "alice", "and", "bob", "are", and "playing". "stone-game10" is invalid because it contains digits.
+
+**Constraints:**
+
+*   `1 <= sentence.length <= 1000`
+*   `sentence` only contains lowercase English letters, digits, `' '`, `'-'`, `'!'`, `'.'`, and `','`.
+*   There will be at least `1` token.

src/main/java/g2001_2100/s2048_next_greater_numerically_balanced_number/Solution.java

@@ -0,0 +1,43 @@
+package g2001_2100.s2048_next_greater_numerically_balanced_number;
+
+// #Medium #Math #Backtracking #Enumeration #2022_05_26_Time_2_ms_(95.19%)_Space_41.8_MB_(72.12%)
+
+public class Solution {
+    public int nextBeautifulNumber(int n) {
+        int[] arr = new int[] {0, 1, 2, 3, 4, 5, 6};
+        boolean[] select = new boolean[7];
+        int d = n == 0 ? 1 : (int) Math.log10(n) + 1;
+        return solve(1, n, d, 0, select, arr);
+    }
+
+    private int solve(int i, int n, int d, int sz, boolean[] select, int[] arr) {
+        if (sz > d + 1) {
+            return Integer.MAX_VALUE;
+        }
+        if (i == select.length) {
+            return sz >= d ? make(0, n, sz, select, arr) : Integer.MAX_VALUE;
+        }
+        int ans = solve(i + 1, n, d, sz, select, arr);
+        select[i] = true;
+        ans = Math.min(ans, solve(i + 1, n, d, sz + i, select, arr));
+        select[i] = false;
+        return ans;
+    }
+
+    private int make(int cur, int n, int end, boolean[] select, int[] arr) {
+        if (end == 0) {
+            return cur > n ? cur : Integer.MAX_VALUE;
+        }
+
+        int ans = Integer.MAX_VALUE;
+        for (int j = 1; j < arr.length; j++) {
+            if (!select[j] || arr[j] == 0) {
+                continue;
+            }
+            --arr[j];
+            ans = Math.min(make(10 * cur + j, n, end - 1, select, arr), ans);
+            ++arr[j];
+        }
+        return ans;
+    }
+}

src/main/java/g2001_2100/s2048_next_greater_numerically_balanced_number/readme.md

@@ -0,0 +1,57 @@
+2048\. Next Greater Numerically Balanced Number
+
+Medium
+
+An integer `x` is **numerically balanced** if for every digit `d` in the number `x`, there are **exactly** `d` occurrences of that digit in `x`.
+
+Given an integer `n`, return _the **smallest numerically balanced** number **strictly greater** than_ `n`_._
+
+**Example 1:**
+
+**Input:** n = 1
+
+**Output:** 22
+
+**Explanation:** 
+
+22 is numerically balanced since: 
+
+- The digit 2 occurs 2 times. 
+  
+It is also the smallest numerically balanced number strictly greater than 1.
+
+**Example 2:**
+
+**Input:** n = 1000
+
+**Output:** 1333
+
+**Explanation:** 
+
+1333 is numerically balanced since:
+
+- The digit 1 occurs 1 time. 
+
+- The digit 3 occurs 3 times. 
+  
+It is also the smallest numerically balanced number strictly greater than 1000. Note that 1022 cannot be the answer because 0 appeared more than 0 times.
+
+**Example 3:**
+
+**Input:** n = 3000
+
+**Output:** 3133
+
+**Explanation:** 
+
+3133 is numerically balanced since: 
+
+- The digit 1 occurs 1 time. 
+
+- The digit 3 occurs 3 times. 
+  
+It is also the smallest numerically balanced number strictly greater than 3000.
+
+**Constraints:**
+
+*   <code>0 <= n <= 10<sup>6</sup></code>