Added tasks 2368, 2369, 2370.

Author: ThanhNIT

src/main/java/g2301_2400/s2368_reachable_nodes_with_restrictions/Solution.java

@@ -0,0 +1,46 @@
+package g2301_2400.s2368_reachable_nodes_with_restrictions;
+
+// #Medium #Array #Tree #Graph #Hash_Table #Depth_First_Search #Breadth_First_Search
+// #2022_08_15_Time_88_ms_(42.86%)_Space_201.1_MB_(14.29%)
+
+import java.util.LinkedList;
+
+public class Solution {
+    public int reachableNodes(int n, int[][] edges, int[] restricted) {
+        LinkedList<Integer>[] adj = new LinkedList[n];
+        for (int i = 0; i < n - 1; i++) {
+            if (adj[edges[i][0]] == null) {
+                LinkedList<Integer> source = new LinkedList<>();
+                source.add(edges[i][1]);
+                adj[edges[i][0]] = source;
+            } else {
+                adj[edges[i][0]].add(edges[i][1]);
+            }
+            if (adj[edges[i][1]] == null) {
+                LinkedList<Integer> dest = new LinkedList<>();
+                dest.add(edges[i][0]);
+                adj[edges[i][1]] = dest;
+            } else {
+                adj[edges[i][1]].add(edges[i][0]);
+            }
+        }
+        boolean[] visited = new boolean[n];
+        for (int res : restricted) {
+            visited[res] = true;
+        }
+        int count = 1;
+        visited[0] = true;
+        return countReachableNodes(0, adj, visited, count);
+    }
+
+    private int countReachableNodes(
+            int source, LinkedList<Integer>[] adj, boolean[] visited, int count) {
+        for (int neighbour : adj[source]) {
+            if (!visited[neighbour]) {
+                visited[neighbour] = true;
+                count = countReachableNodes(neighbour, adj, visited, ++count);
+            }
+        }
+        return count;
+    }
+}

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

@@ -0,0 +1,43 @@
+2368\. Reachable Nodes With Restrictions
+
+Medium
+
+There is an undirected tree with `n` nodes labeled from `0` to `n - 1` and `n - 1` edges.
+
+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. You are also given an integer array `restricted` which represents **restricted** nodes.
+
+Return _the **maximum** number of nodes you can reach from node_ `0` _without visiting a restricted node._
+
+Note that node `0` will **not** be a restricted node.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/06/15/ex1drawio.png)
+
+**Input:** n = 7, edges = [[0,1],[1,2],[3,1],[4,0],[0,5],[5,6]], restricted = [4,5]
+
+**Output:** 4
+
+**Explanation:** The diagram above shows the tree. We have that [0,1,2,3] are the only nodes that can be reached from node 0 without visiting a restricted node.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/06/15/ex2drawio.png)
+
+**Input:** n = 7, edges = [[0,1],[0,2],[0,5],[0,4],[3,2],[6,5]], restricted = [4,2,1]
+
+**Output:** 3
+
+**Explanation:** The diagram above shows the tree. We have that [0,5,6] are the only nodes that can be reached from node 0 without visiting a restricted node.
+
+**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 <= restricted.length < n`
+*   `1 <= restricted[i] < n`
+*   All the values of `restricted` are **unique**.

src/main/java/g2301_2400/s2369_check_if_there_is_a_valid_partition_for_the_array/Solution.java

@@ -0,0 +1,41 @@
+package g2301_2400.s2369_check_if_there_is_a_valid_partition_for_the_array;
+
+// #Medium #Array #Dynamic_Programming #2022_08_15_Time_7_ms_(81.82%)_Space_84.8_MB_(27.27%)
+
+public class Solution {
+    public boolean validPartition(int[] nums) {
+        boolean[] canPartition = new boolean[nums.length + 1];
+        canPartition[0] = true;
+        int diff = nums[1] - nums[0];
+        boolean equal = diff == 0;
+        boolean incOne = diff == 1;
+        canPartition[2] = equal;
+        int count = canPartition[2] ? 0 : 2;
+        for (int i = 3; i < canPartition.length; i++) {
+            diff = nums[i - 1] - nums[i - 2];
+            if (diff == 0) {
+                canPartition[i] = canPartition[i - 2] || (equal && canPartition[i - 3]);
+                equal = true;
+                incOne = false;
+            } else if (diff == 1) {
+                canPartition[i] = incOne && canPartition[i - 3];
+                equal = false;
+                incOne = true;
+            } else if (canPartition[i - 1]) {
+                equal = false;
+                incOne = false;
+            } else {
+                return false;
+            }
+
+            if (canPartition[i]) {
+                count = 0;
+            } else if (count == 2) {
+                return false;
+            } else {
+                count++;
+            }
+        }
+        return canPartition[nums.length];
+    }
+}

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

@@ -0,0 +1,34 @@
+2369\. Check if There is a Valid Partition For The Array
+
+Medium
+
+You are given a **0-indexed** integer array `nums`. You have to partition the array into one or more **contiguous** subarrays.
+
+We call a partition of the array **valid** if each of the obtained subarrays satisfies **one** of the following conditions:
+
+1.  The subarray consists of **exactly** `2` equal elements. For example, the subarray `[2,2]` is good.
+2.  The subarray consists of **exactly** `3` equal elements. For example, the subarray `[4,4,4]` is good.
+3.  The subarray consists of **exactly** `3` consecutive increasing elements, that is, the difference between adjacent elements is `1`. For example, the subarray `[3,4,5]` is good, but the subarray `[1,3,5]` is not.
+
+Return `true` _if the array has **at least** one valid partition_. Otherwise, return `false`.
+
+**Example 1:**
+
+**Input:** nums = [4,4,4,5,6]
+
+**Output:** true
+
+**Explanation:** The array can be partitioned into the subarrays [4,4] and [4,5,6]. This partition is valid, so we return true.
+
+**Example 2:**
+
+**Input:** nums = [1,1,1,2]
+
+**Output:** false
+
+**Explanation:** There is no valid partition for this array.
+
+**Constraints:**
+
+*   <code>2 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>6</sup></code>

src/main/java/g2301_2400/s2370_longest_ideal_subsequence/Solution.java

@@ -0,0 +1,46 @@
+package g2301_2400.s2370_longest_ideal_subsequence;
+
+// #Medium #String #Hash_Table #Dynamic_Programming
+// #2022_08_15_Time_28_ms_(85.71%)_Space_48.6_MB_(85.71%)
+
+@SuppressWarnings("java:S135")
+public class Solution {
+    public int longestIdealString(String s, int k) {
+        int ans = 1;
+        int[] array = new int[26];
+        for (int i = 0; i < s.length(); i++) {
+            int curr = s.charAt(i) - 'a';
+            int currans = 1;
+            int temp = k;
+            array[curr] += 1;
+            int j = curr - 1;
+            while (temp > 0) {
+                if (j == -1) {
+                    break;
+                }
+                currans = Math.max(currans, array[j] + 1);
+                temp--;
+                if (j == 0) {
+                    break;
+                }
+                j--;
+            }
+            temp = k;
+            j = curr + 1;
+            while (temp > 0) {
+                if (j == 26) {
+                    break;
+                }
+                currans = Math.max(currans, array[j] + 1);
+                temp--;
+                if (j == 25) {
+                    break;
+                }
+                j++;
+            }
+            array[curr] = Math.max(currans, array[curr]);
+            ans = Math.max(ans, array[curr]);
+        }
+        return ans;
+    }
+}

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

@@ -0,0 +1,36 @@
+2370\. Longest Ideal Subsequence
+
+Medium
+
+You are given a string `s` consisting of lowercase letters and an integer `k`. We call a string `t` **ideal** if the following conditions are satisfied:
+
+*   `t` is a **subsequence** of the string `s`.
+*   The absolute difference in the alphabet order of every two **adjacent** letters in `t` is less than or equal to `k`.
+
+Return _the length of the **longest** ideal string_.
+
+A **subsequence** is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.
+
+**Note** that the alphabet order is not cyclic. For example, the absolute difference in the alphabet order of `'a'` and `'z'` is `25`, not `1`.
+
+**Example 1:**
+
+**Input:** s = "acfgbd", k = 2
+
+**Output:** 4
+
+**Explanation:** The longest ideal string is "acbd". The length of this string is 4, so 4 is returned. Note that "acfgbd" is not ideal because 'c' and 'f' have a difference of 3 in alphabet order.
+
+**Example 2:**
+
+**Input:** s = "abcd", k = 3
+
+**Output:** 4
+
+**Explanation:** The longest ideal string is "abcd". The length of this string is 4, so 4 is returned.
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `0 <= k <= 25`
+*   `s` consists of lowercase English letters.

src/test/java/g2301_2400/s2368_reachable_nodes_with_restrictions/SolutionTest.java

@@ -0,0 +1,30 @@
+package g2301_2400.s2368_reachable_nodes_with_restrictions;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void reachableNodes() {
+        assertThat(
+                new Solution()
+                        .reachableNodes(
+                                7,
+                                new int[][] {{0, 1}, {1, 2}, {3, 1}, {4, 0}, {0, 5}, {5, 6}},
+                                new int[] {4, 5}),
+                equalTo(4));
+    }
+
+    @Test
+    void reachableNodes2() {
+        assertThat(
+                new Solution()
+                        .reachableNodes(
+                                7,
+                                new int[][] {{0, 1}, {0, 2}, {0, 5}, {0, 4}, {3, 2}, {6, 5}},
+                                new int[] {4, 2, 1}),
+                equalTo(3));
+    }
+}

src/test/java/g2301_2400/s2369_check_if_there_is_a_valid_partition_for_the_array/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2301_2400.s2369_check_if_there_is_a_valid_partition_for_the_array;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void validPartition() {
+        assertThat(new Solution().validPartition(new int[] {4, 4, 4, 5, 6}), equalTo(true));
+    }
+
+    @Test
+    void validPartition2() {
+        assertThat(new Solution().validPartition(new int[] {1, 1, 1, 2}), equalTo(false));
+    }
+}

src/test/java/g2301_2400/s2370_longest_ideal_subsequence/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2301_2400.s2370_longest_ideal_subsequence;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void longestIdealString() {
+        assertThat(new Solution().longestIdealString("acfgbd", 2), equalTo(4));
+    }
+
+    @Test
+    void longestIdealString2() {
+        assertThat(new Solution().longestIdealString("abcd", 3), equalTo(4));
+    }
+}