Added tasks 2389, 2390, 2391, 2392.

Author: javadev

README.md

@@ -1848,6 +1848,10 @@ implementation 'com.github.javadev:leetcode-in-java:1.13'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2392 |[Build a Matrix With Conditions](src/main/java/g2301_2400/s2392_build_a_matrix_with_conditions/Solution.java)| Hard | Array, Matrix, Graph, Topological_Sort | 9 | 97.22
+| 2391 |[Minimum Amount of Time to Collect Garbage](src/main/java/g2301_2400/s2391_minimum_amount_of_time_to_collect_garbage/Solution.java)| Medium | Array, String, Prefix_Sum | 7 | 98.86
+| 2390 |[Removing Stars From a String](src/main/java/g2301_2400/s2390_removing_stars_from_a_string/Solution.java)| Medium | String, Stack, Simulation | 31 | 90.55
+| 2389 |[Longest Subsequence With Limited Sum](src/main/java/g2301_2400/s2389_longest_subsequence_with_limited_sum/Solution.java)| Easy | Array, Sorting, Greedy, Binary_Search, Prefix_Sum | 4 | 99.97
 | 2386 |[Find the K-Sum of an Array](src/main/java/g2301_2400/s2386_find_the_k_sum_of_an_array/Solution.java)| Hard | Array, Sorting, Heap_Priority_Queue | 75 | 100.00
 | 2385 |[Amount of Time for Binary Tree to Be Infected](src/main/java/g2301_2400/s2385_amount_of_time_for_binary_tree_to_be_infected/Solution.java)| Medium | Tree, Binary_Tree, Depth_First_Search, Breadth_First_Search | 20 | 100.00
 | 2384 |[Largest Palindromic Number](src/main/java/g2301_2400/s2384_largest_palindromic_number/Solution.java)| Medium | String, Hash_Table, Greedy | 26 | 100.00

src/main/java/g2301_2400/s2389_longest_subsequence_with_limited_sum/Solution.java

@@ -0,0 +1,24 @@
+package g2301_2400.s2389_longest_subsequence_with_limited_sum;
+
+// #Easy #Array #Sorting #Greedy #Binary_Search #Prefix_Sum
+// #2022_09_02_Time_4_ms_(99.97%)_Space_42.7_MB_(95.35%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int[] answerQueries(int[] nums, int[] queries) {
+        // we can sort the nums because the order of the subsequence does not matter
+        Arrays.sort(nums);
+        for (int i = 1; i < nums.length; i++) {
+            nums[i] = nums[i] + nums[i - 1];
+        }
+        for (int i = 0; i < queries.length; i++) {
+            int j = Arrays.binarySearch(nums, queries[i]);
+            if (j < 0) {
+                j = -j - 2;
+            }
+            queries[i] = j + 1;
+        }
+        return queries;
+    }
+}

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

@@ -0,0 +1,38 @@
+2389\. Longest Subsequence With Limited Sum
+
+Easy
+
+You are given an integer array `nums` of length `n`, and an integer array `queries` of length `m`.
+
+Return _an array_ `answer` _of length_ `m` _where_ `answer[i]` _is the **maximum** size of a **subsequence** that you can take from_ `nums` _such that the **sum** of its elements is less than or equal to_ `queries[i]`.
+
+A **subsequence** is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.
+
+**Example 1:**
+
+**Input:** nums = [4,5,2,1], queries = [3,10,21]
+
+**Output:** [2,3,4]
+
+**Explanation:** We answer the queries as follows:
+
+- The subsequence [2,1] has a sum less than or equal to 3. It can be proven that 2 is the maximum size of such a subsequence, so answer[0] = 2.
+
+- The subsequence [4,5,1] has a sum less than or equal to 10. It can be proven that 3 is the maximum size of such a subsequence, so answer[1] = 3.
+
+- The subsequence [4,5,2,1] has a sum less than or equal to 21. It can be proven that 4 is the maximum size of such a subsequence, so answer[2] = 4. 
+
+**Example 2:**
+
+**Input:** nums = [2,3,4,5], queries = [1]
+
+**Output:** [0]
+
+**Explanation:** The empty subsequence is the only subsequence that has a sum less than or equal to 1, so answer[0] = 0.
+
+**Constraints:**
+
+*   `n == nums.length`
+*   `m == queries.length`
+*   `1 <= n, m <= 1000`
+*   <code>1 <= nums[i], queries[i] <= 10<sup>6</sup></code>

src/main/java/g2301_2400/s2390_removing_stars_from_a_string/Solution.java

@@ -0,0 +1,20 @@
+package g2301_2400.s2390_removing_stars_from_a_string;
+
+// #Medium #String #Stack #Simulation #2022_09_02_Time_31_ms_(90.55%)_Space_62.6_MB_(76.40%)
+
+public class Solution {
+    public String removeStars(String s) {
+        StringBuilder sb = new StringBuilder();
+        int stars = 0;
+        for (int i = s.length() - 1; i >= 0; --i) {
+            if (s.charAt(i) == '*') {
+                ++stars;
+            } else if (stars > 0) {
+                --stars;
+            } else {
+                sb.append(s.charAt(i));
+            }
+        }
+        return sb.reverse().toString();
+    }
+}

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

@@ -0,0 +1,47 @@
+2390\. Removing Stars From a String
+
+Medium
+
+You are given a string `s`, which contains stars `*`.
+
+In one operation, you can:
+
+*   Choose a star in `s`.
+*   Remove the closest **non-star** character to its **left**, as well as remove the star itself.
+
+Return _the string after **all** stars have been removed_.
+
+**Note:**
+
+*   The input will be generated such that the operation is always possible.
+*   It can be shown that the resulting string will always be unique.
+
+**Example 1:**
+
+**Input:** s = "leet\*\*cod\*e"
+
+**Output:** "lecoe"
+
+**Explanation:** Performing the removals from left to right:
+
+- The closest character to the 1<sup>st</sup> star is 't' in "lee**<ins>t</ins>**\*\*cod\*e". s becomes "lee\*cod\*e".
+
+- The closest character to the 2<sup>nd</sup> star is 'e' in "le**<ins>e</ins>**\*cod\*e". s becomes "lecod\*e".
+
+- The closest character to the 3<sup>rd</sup> star is 'd' in "leco**<ins>d</ins>**\*e". s becomes "lecoe".
+
+There are no more stars, so we return "lecoe".
+
+**Example 2:**
+
+**Input:** s = "erase\*\*\*\*\*"
+
+**Output:** ""
+
+**Explanation:** The entire string is removed, so we return an empty string. 
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists of lowercase English letters and stars `*`.
+*   The operation above can be performed on `s`.

src/main/java/g2301_2400/s2391_minimum_amount_of_time_to_collect_garbage/Solution.java

@@ -0,0 +1,34 @@
+package g2301_2400.s2391_minimum_amount_of_time_to_collect_garbage;
+
+// #Medium #Array #String #Prefix_Sum #2022_09_02_Time_7_ms_(98.86%)_Space_92_MB_(72.81%)
+
+public class Solution {
+    public int garbageCollection(String[] garbage, int[] travel) {
+        int cTime = 0;
+        for (String str : garbage) {
+            cTime += str.length();
+        }
+        int n = travel.length;
+        for (int i = 1; i < n; i++) {
+            travel[i] += travel[i - 1];
+        }
+        int mT = getMostTra(garbage, 'M');
+        int pT = getMostTra(garbage, 'P');
+        int gT = getMostTra(garbage, 'G');
+        int m = mT <= 0 ? 0 : travel[mT - 1];
+        int p = pT <= 0 ? 0 : travel[pT - 1];
+        int g = gT <= 0 ? 0 : travel[gT - 1];
+        int tTime = m + p + g;
+        return cTime + tTime;
+    }
+
+    private int getMostTra(String[] garbage, char c) {
+        int n = garbage.length;
+        for (int i = n - 1; i >= 0; i--) {
+            if (garbage[i].indexOf(c) != -1) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}

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

@@ -0,0 +1,75 @@
+2391\. Minimum Amount of Time to Collect Garbage
+
+Medium
+
+You are given a **0-indexed** array of strings `garbage` where `garbage[i]` represents the assortment of garbage at the <code>i<sup>th</sup></code> house. `garbage[i]` consists only of the characters `'M'`, `'P'` and `'G'` representing one unit of metal, paper and glass garbage respectively. Picking up **one** unit of any type of garbage takes `1` minute.
+
+You are also given a **0-indexed** integer array `travel` where `travel[i]` is the number of minutes needed to go from house `i` to house `i + 1`.
+
+There are three garbage trucks in the city, each responsible for picking up one type of garbage. Each garbage truck starts at house `0` and must visit each house **in order**; however, they do **not** need to visit every house.
+
+Only **one** garbage truck may be used at any given moment. While one truck is driving or picking up garbage, the other two trucks **cannot** do anything.
+
+Return _the **minimum** number of minutes needed to pick up all the garbage._
+
+**Example 1:**
+
+**Input:** garbage = ["G","P","GP","GG"], travel = [2,4,3]
+
+**Output:** 21
+
+**Explanation:**
+
+The paper garbage truck:
+
+1. Travels from house 0 to house 1
+
+2. Collects the paper garbage at house 1
+
+3. Travels from house 1 to house 2
+
+4. Collects the paper garbage at house 2 Altogether, it takes 8 minutes to pick up all the paper garbage.
+
+The glass garbage truck:
+
+1. Collects the glass garbage at house 0
+
+2. Travels from house 0 to house 1
+
+3. Travels from house 1 to house 2
+
+4. Collects the glass garbage at house 2
+
+5. Travels from house 2 to house 3
+
+6. Collects the glass garbage at house 3
+
+Altogether, it takes 13 minutes to pick up all the glass garbage.
+
+Since there is no metal garbage, we do not need to consider the metal garbage truck.
+
+Therefore, it takes a total of 8 + 13 = 21 minutes to collect all the garbage. 
+
+**Example 2:**
+
+**Input:** garbage = ["MMM","PGM","GP"], travel = [3,10]
+
+**Output:** 37
+
+**Explanation:**
+
+The metal garbage truck takes 7 minutes to pick up all the metal garbage.
+
+The paper garbage truck takes 15 minutes to pick up all the paper garbage.
+
+The glass garbage truck takes 15 minutes to pick up all the glass garbage.
+
+It takes a total of 7 + 15 + 15 = 37 minutes to collect all the garbage. 
+
+**Constraints:**
+
+*   <code>2 <= garbage.length <= 10<sup>5</sup></code>
+*   `garbage[i]` consists of only the letters `'M'`, `'P'`, and `'G'`.
+*   `1 <= garbage[i].length <= 10`
+*   `travel.length == garbage.length - 1`
+*   `1 <= travel[i] <= 100`

src/main/java/g2301_2400/s2392_build_a_matrix_with_conditions/Solution.java

@@ -0,0 +1,82 @@
+package g2301_2400.s2392_build_a_matrix_with_conditions;
+
+// #Hard #Array #Matrix #Graph #Topological_Sort
+// #2022_09_02_Time_9_ms_(97.22%)_Space_50.2_MB_(99.69%)
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+
+public class Solution {
+    // Using topological sort to solve this problem
+    public int[][] buildMatrix(int k, int[][] rowC, int[][] colC) {
+        // First, get the topo-sorted of row and col
+        List<Integer> row = toposort(k, rowC);
+        List<Integer> col = toposort(k, colC);
+        // base case: when the length of row or col is less than k, return empty.
+        // That is: there is a loop in established graph
+        if (row.size() < k || col.size() < k) {
+            return new int[0][0];
+        }
+        int[][] res = new int[k][k];
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int i = 0; i < k; i++) {
+            // we record the number corresbonding to each column:
+            // [number, column index]
+            map.put(col.get(i), i);
+        }
+        // col: 3 2 1
+        // row: 1 3 2
+        for (int i = 0; i < k; i++) {
+            // For each row: we have number row.get(i). And we need to know
+            // which column we need to assign, which is from map.get(row.get(i))
+            // known by map.get()
+            res[i][map.get(row.get(i))] = row.get(i);
+        }
+        return res;
+    }
+
+    private List<Integer> toposort(int k, int[][] matrix) {
+        // need a int[] to record the indegree of each number [1, k]
+        int[] deg = new int[k + 1];
+        // need a list to record the order of each number, then return this list
+        List<Integer> res = new ArrayList<>();
+        // need a 2-D list to be the graph, and fill the graph
+        List<List<Integer>> graph = new ArrayList<>();
+        for (int i = 0; i < k; i++) {
+            graph.add(new ArrayList<>());
+        }
+        // need a queue to do the BFS
+        Queue<Integer> queue = new LinkedList<>();
+        // First, we need to establish the graph, following the given matrix
+        for (int[] a : matrix) {
+            int from = a[0];
+            int to = a[1];
+            graph.get(from - 1).add(to);
+            deg[to]++;
+        }
+        // Second, after building a graph, we start the bfs,
+        // that is, traverse the node with 0 degree
+        for (int i = 1; i <= k; i++) {
+            if (deg[i] == 0) {
+                queue.offer(i);
+                res.add(i);
+            }
+        }
+        // Third, start the topo sort
+        while (!queue.isEmpty()) {
+            int node = queue.poll();
+            List<Integer> list = graph.get(node - 1);
+            for (int i : list) {
+                if (--deg[i] == 0) {
+                    queue.offer(i);
+                    res.add(i);
+                }
+            }
+        }
+        return res;
+    }
+}