Added tasks 1914, 1915, 1916, 1920, 1921.

Author: ThanhNIT

src/main/java/g1901_2000/s1914_cyclically_rotating_a_grid/Solution.java

@@ -0,0 +1,64 @@
+package g1901_2000.s1914_cyclically_rotating_a_grid;
+
+// #Medium #Array #Matrix #Simulation #2022_05_14_Time_2_ms_(91.30%)_Space_43_MB_(86.96%)
+
+public class Solution {
+    public int[][] rotateGrid(int[][] grid, int k) {
+        rotateInternal(grid, 0, grid[0].length - 1, 0, grid.length - 1, k);
+        return grid;
+    }
+
+    private void rotateInternal(int[][] grid, int left, int right, int up, int bottom, int k) {
+        if (left > right || up > bottom) {
+            return;
+        }
+        int loopLen = (right - left + 1) * 2 + (bottom - up + 1) * 2 - 4;
+        int realK = k % loopLen;
+        if (realK != 0) {
+            rotateLayer(grid, left, right, up, bottom, realK);
+        }
+        rotateInternal(grid, left + 1, right - 1, up + 1, bottom - 1, k);
+    }
+
+    private void rotateLayer(int[][] grid, int left, int right, int up, int bottom, int k) {
+        int[] startPoint = new int[] {up, left};
+        int loopLen = (right - left + 1) * 2 + (bottom - up + 1) * 2 - 4;
+        int[] arr = new int[loopLen];
+        int idx = 0;
+        int[] currPoint = startPoint;
+        int[] startPointAfterRotation = null;
+
+        while (idx < arr.length) {
+            arr[idx] = grid[currPoint[0]][currPoint[1]];
+            idx++;
+            currPoint = getNextPosCC(left, right, up, bottom, currPoint);
+            if (idx == k) {
+                startPointAfterRotation = currPoint;
+            }
+        }
+
+        idx = 0;
+        currPoint = startPointAfterRotation;
+        if (currPoint != null) {
+            while (idx < arr.length) {
+                grid[currPoint[0]][currPoint[1]] = arr[idx];
+                idx++;
+                currPoint = getNextPosCC(left, right, up, bottom, currPoint);
+            }
+        }
+    }
+
+    private int[] getNextPosCC(int left, int right, int up, int bottom, int[] curr) {
+        int x = curr[0];
+        int y = curr[1];
+        if (x == up && y > left) {
+            return new int[] {x, y - 1};
+        } else if (y == left && x < bottom) {
+            return new int[] {x + 1, y};
+        } else if (x == bottom && y < right) {
+            return new int[] {x, y + 1};
+        } else {
+            return new int[] {x - 1, y};
+        }
+    }
+}

src/main/java/g1901_2000/s1914_cyclically_rotating_a_grid/readme.md

@@ -0,0 +1,44 @@
+1914\. Cyclically Rotating a Grid
+
+Medium
+
+You are given an `m x n` integer matrix `grid`, where `m` and `n` are both **even** integers, and an integer `k`.
+
+The matrix is composed of several layers, which is shown in the below image, where each color is its own layer:
+
+![](https://assets.leetcode.com/uploads/2021/06/10/ringofgrid.png)
+
+A cyclic rotation of the matrix is done by cyclically rotating **each layer** in the matrix. To cyclically rotate a layer once, each element in the layer will take the place of the adjacent element in the **counter-clockwise** direction. An example rotation is shown below:
+
+![](https://assets.leetcode.com/uploads/2021/06/22/explanation_grid.jpg)
+
+Return _the matrix after applying_ `k` _cyclic rotations to it_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/06/19/rod2.png)
+
+**Input:** grid = [[40,10],[30,20]], k = 1
+
+**Output:** [[10,20],[40,30]]
+
+**Explanation:** The figures above represent the grid at every state.
+
+**Example 2:**
+
+**![](https://assets.leetcode.com/uploads/2021/06/10/ringofgrid5.png)** **![](https://assets.leetcode.com/uploads/2021/06/10/ringofgrid6.png)** **![](https://assets.leetcode.com/uploads/2021/06/10/ringofgrid7.png)**
+
+**Input:** grid = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]], k = 2
+
+**Output:** [[3,4,8,12],[2,11,10,16],[1,7,6,15],[5,9,13,14]]
+
+**Explanation:** The figures above represent the grid at every state.
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `2 <= m, n <= 50`
+*   Both `m` and `n` are **even** integers.
+*   `1 <= grid[i][j] <= 5000`
+*   <code>1 <= k <= 10<sup>9</sup></code>

src/main/java/g1901_2000/s1915_number_of_wonderful_substrings/Solution.java

@@ -0,0 +1,22 @@
+package g1901_2000.s1915_number_of_wonderful_substrings;
+
+// #Medium #String #Hash_Table #Bit_Manipulation #Prefix_Sum
+// #2022_05_14_Time_31_ms_(82.46%)_Space_54.6_MB_(38.60%)
+
+public class Solution {
+    public long wonderfulSubstrings(String word) {
+        int[] count = new int[1024];
+        long res = 0;
+        int cur = 0;
+        count[0] = 1;
+        for (int i = 0; i < word.length(); i++) {
+            cur ^= 1 << (word.charAt(i) - 'a');
+            res += count[cur];
+            for (int j = 0; j < 10; j++) {
+                res += count[cur ^ (1 << j)];
+            }
+            ++count[cur];
+        }
+        return res;
+    }
+}

src/main/java/g1901_2000/s1915_number_of_wonderful_substrings/readme.md

@@ -0,0 +1,70 @@
+1915\. Number of Wonderful Substrings
+
+Medium
+
+A **wonderful** string is a string where **at most one** letter appears an **odd** number of times.
+
+*   For example, `"ccjjc"` and `"abab"` are wonderful, but `"ab"` is not.
+
+Given a string `word` that consists of the first ten lowercase English letters (`'a'` through `'j'`), return _the **number of wonderful non-empty substrings** in_ `word`_. If the same substring appears multiple times in_ `word`_, then count **each occurrence** separately._
+
+A **substring** is a contiguous sequence of characters in a string.
+
+**Example 1:**
+
+**Input:** word = "aba"
+
+**Output:** 4
+
+**Explanation:** The four wonderful substrings are underlined below: 
+
+- "**a**ba" -> "a" 
+
+- "a**b**a" -> "b" 
+
+- "ab**a**" -> "a" 
+
+- "**aba**" -> "aba"
+
+**Example 2:**
+
+**Input:** word = "aabb"
+
+**Output:** 9
+
+**Explanation:** The nine wonderful substrings are underlined below: 
+
+- "**a**abb" -> "a" 
+
+- "**aa**bb" -> "aa" 
+
+- "**aab**b" -> "aab" 
+
+- "**aabb**" -> "aabb" 
+
+- "a**a**bb" -> "a" 
+
+- "a**abb**" -> "abb" 
+
+- "aa**b**b" -> "b" 
+
+- "aa**bb**" -> "bb" 
+
+- "aab**b**" -> "b"
+
+**Example 3:**
+
+**Input:** word = "he"
+
+**Output:** 2
+
+**Explanation:** The two wonderful substrings are underlined below: 
+
+- "**h**e" -> "h" 
+
+- "h**e**" -> "e"
+
+**Constraints:**
+
+*   <code>1 <= word.length <= 10<sup>5</sup></code>
+*   `word` consists of lowercase English letters from `'a'` to `'j'`.

src/main/java/g1901_2000/s1916_count_ways_to_build_rooms_in_an_ant_colony/Solution.java

@@ -0,0 +1,70 @@
+package g1901_2000.s1916_count_ways_to_build_rooms_in_an_ant_colony;
+
+// #Hard #Dynamic_Programming #Math #Tree #Graph #Topological_Sort #Combinatorics
+// #2022_05_14_Time_1527_ms_(34.38%)_Space_106_MB_(87.50%)
+
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Solution {
+    private static final int MOD = 1000000007;
+    private List<Integer>[] graph;
+    private long[] fact;
+
+    public int waysToBuildRooms(int[] a) {
+        int n = a.length;
+        graph = new ArrayList[n];
+        Arrays.setAll(graph, e -> new ArrayList<>());
+
+        fact = new long[a.length + 10];
+        fact[0] = fact[1] = 1;
+        for (int i = 2; i < fact.length; i++) {
+            fact[i] = fact[i - 1] * i;
+            fact[i] %= MOD;
+        }
+
+        for (int i = 1; i < a.length; i++) {
+            int pre = a[i];
+            graph[pre].add(i);
+        }
+
+        long[] res = dfs(0);
+        return (int) (res[1] % MOD);
+    }
+
+    private long[] dfs(int root) {
+        long[] res = new long[] {1, 0};
+        int cnt = 0;
+        List<long[]> list = new ArrayList<>();
+        for (int next : graph[root]) {
+            long[] v = dfs(next);
+            cnt += v[0];
+            list.add(v);
+        }
+
+        res[0] += cnt;
+        long com = 1;
+        for (long[] p : list) {
+            long choose = c(cnt, (int) (p[0]));
+            cnt -= p[0];
+            com = com * choose;
+            com %= MOD;
+            com = com * p[1];
+            com %= MOD;
+        }
+
+        res[1] = com;
+        return res;
+    }
+
+    private long c(int i, int j) {
+        long mod = 1000000007;
+        long a = fact[i];
+        long b = ((fact[i - j] % mod) * (fact[j] % mod)) % mod;
+        BigInteger value = BigInteger.valueOf(b);
+        long binverse = value.modInverse(BigInteger.valueOf(mod)).longValue();
+        return ((a) * (binverse % mod)) % mod;
+    }
+}

src/main/java/g1901_2000/s1916_count_ways_to_build_rooms_in_an_ant_colony/readme.md

@@ -0,0 +1,49 @@
+1916\. Count Ways to Build Rooms in an Ant Colony
+
+Hard
+
+You are an ant tasked with adding `n` new rooms numbered `0` to `n-1` to your colony. You are given the expansion plan as a **0-indexed** integer array of length `n`, `prevRoom`, where `prevRoom[i]` indicates that you must build room `prevRoom[i]` before building room `i`, and these two rooms must be connected **directly**. Room `0` is already built, so `prevRoom[0] = -1`. The expansion plan is given such that once all the rooms are built, every room will be reachable from room `0`.
+
+You can only build **one room** at a time, and you can travel freely between rooms you have **already built** only if they are **connected**. You can choose to build **any room** as long as its **previous room** is already built.
+
+Return _the **number of different orders** you can build all the rooms in_. Since the answer may be large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/06/19/d1.JPG)
+
+**Input:** prevRoom = [-1,0,1]
+
+**Output:** 1
+
+**Explanation:** There is only one way to build the additional rooms: 0 → 1 → 2
+
+**Example 2:**
+
+**![](https://assets.leetcode.com/uploads/2021/06/19/d2.JPG)**
+
+**Input:** prevRoom = [-1,0,0,1,2]
+
+**Output:** 6
+
+**Explanation:** The 6 ways are: 
+
+0 → 1 → 3 → 2 → 4 
+
+0 → 2 → 4 → 1 → 3 
+
+0 → 1 → 2 → 3 → 4 
+
+0 → 1 → 2 → 4 → 3 
+
+0 → 2 → 1 → 3 → 4 
+
+0 → 2 → 1 → 4 → 3
+
+**Constraints:**
+
+*   `n == prevRoom.length`
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   `prevRoom[0] == -1`
+*   `0 <= prevRoom[i] < n` for all `1 <= i < n`
+*   Every room is reachable from room `0` once all the rooms are built.

src/main/java/g1901_2000/s1920_build_array_from_permutation/Solution.java

@@ -0,0 +1,13 @@
+package g1901_2000.s1920_build_array_from_permutation;
+
+// #Easy #Array #Simulation #2022_05_14_Time_1_ms_(94.23%)_Space_54.1_MB_(13.18%)
+
+public class Solution {
+    public int[] buildArray(int[] nums) {
+        int[] ans = new int[nums.length];
+        for (int i = 0; i < nums.length; i++) {
+            ans[i] = nums[nums[i]];
+        }
+        return ans;
+    }
+}

src/main/java/g1901_2000/s1920_build_array_from_permutation/readme.md

@@ -0,0 +1,39 @@
+1920\. Build Array from Permutation
+
+Easy
+
+Given a **zero-based permutation** `nums` (**0-indexed**), build an array `ans` of the **same length** where `ans[i] = nums[nums[i]]` for each `0 <= i < nums.length` and return it.
+
+A **zero-based permutation** `nums` is an array of **distinct** integers from `0` to `nums.length - 1` (**inclusive**).
+
+**Example 1:**
+
+**Input:** nums = [0,2,1,5,3,4]
+
+**Output:** [0,1,2,4,5,3]
+
+**Explanation:** The array ans is built as follows: 
+
+ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]] 
+    = [nums[0], nums[2], nums[1], nums[5], nums[3], nums[4]]    
+    = [0,1,2,4,5,3]
+
+**Example 2:**
+
+**Input:** nums = [5,0,1,2,3,4]
+
+**Output:** [4,5,0,1,2,3]
+
+**Explanation:** The array ans is built as follows: 
+
+ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]] 
+    = [nums[5], nums[0], nums[1], nums[2], nums[3], nums[4]] 
+    = [4,5,0,1,2,3]
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   `0 <= nums[i] < nums.length`
+*   The elements in `nums` are **distinct**.
+
+**Follow-up:** Can you solve it without using an extra space (i.e., `O(1)` memory)?