Added tasks 1855, 1856, 1857, 1859, 1860.

Author: ThanhNIT

src/main/java/g1801_1900/s1855_maximum_distance_between_a_pair_of_values/Solution.java

@@ -0,0 +1,25 @@
+package g1801_1900.s1855_maximum_distance_between_a_pair_of_values;
+
+// #Medium #Array #Greedy #Binary_Search #Two_Pointers #Binary_Search_I_Day_11
+// #2022_05_08_Time_4_ms_(62.20%)_Space_102.5_MB_(38.31%)
+
+public class Solution {
+    public int maxDistance(int[] n1, int[] n2) {
+        int n = n1.length;
+        int m = n2.length;
+        int po1 = 0;
+        int po2 = 0;
+        int res = 0;
+        while (po1 < n && po2 < m) {
+            if (n1[po1] > n2[po2]) {
+                po1++;
+            } else {
+                if (po2 != po1) {
+                    res = Math.max(res, po2 - po1);
+                }
+                po2++;
+            }
+        }
+        return res;
+    }
+}

src/main/java/g1801_1900/s1855_maximum_distance_between_a_pair_of_values/readme.md

@@ -0,0 +1,41 @@
+1855\. Maximum Distance Between a Pair of Values
+
+Medium
+
+You are given two **non-increasing 0-indexed** integer arrays `nums1` and `nums2`.
+
+A pair of indices `(i, j)`, where `0 <= i < nums1.length` and `0 <= j < nums2.length`, is **valid** if both `i <= j` and `nums1[i] <= nums2[j]`. The **distance** of the pair is `j - i`.
+
+Return _the **maximum distance** of any **valid** pair_ `(i, j)`_. If there are no valid pairs, return_ `0`.
+
+An array `arr` is **non-increasing** if `arr[i-1] >= arr[i]` for every `1 <= i < arr.length`.
+
+**Example 1:**
+
+**Input:** nums1 = [55,30,5,4,2], nums2 = [100,20,10,10,5]
+
+**Output:** 2
+
+**Explanation:** The valid pairs are (0,0), (2,2), (2,3), (2,4), (3,3), (3,4), and (4,4). The maximum distance is 2 with pair (2,4).
+
+**Example 2:**
+
+**Input:** nums1 = [2,2,2], nums2 = [10,10,1]
+
+**Output:** 1
+
+**Explanation:** The valid pairs are (0,0), (0,1), and (1,1). The maximum distance is 1 with pair (0,1).
+
+**Example 3:**
+
+**Input:** nums1 = [30,29,19,5], nums2 = [25,25,25,25,25]
+
+**Output:** 2
+
+**Explanation:** The valid pairs are (2,2), (2,3), (2,4), (3,3), and (3,4). The maximum distance is 2 with pair (2,4).
+
+**Constraints:**
+
+*   <code>1 <= nums1.length, nums2.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums1[i], nums2[j] <= 10<sup>5</sup></code>
+*   Both `nums1` and `nums2` are **non-increasing**.

src/main/java/g1801_1900/s1856_maximum_subarray_min_product/Solution.java

@@ -0,0 +1,45 @@
+package g1801_1900.s1856_maximum_subarray_min_product;
+
+// #Medium #Array #Stack #Prefix_Sum #Monotonic_Stack
+// #2022_05_08_Time_28_ms_(92.10%)_Space_98.4_MB_(72.64%)
+
+public class Solution {
+    public int maxSumMinProduct(int[] nums) {
+        int n = nums.length;
+        int mod = (int) (1e9 + 7);
+        if (n == 1) {
+            return (int) (((long) nums[0] * (long) nums[0]) % mod);
+        }
+        int[] left = new int[n];
+        left[0] = -1;
+        for (int i = 1; i < n; i++) {
+            int p = i - 1;
+            while (p >= 0 && nums[p] >= nums[i]) {
+                p = left[p];
+            }
+            left[i] = p;
+        }
+        int[] right = new int[n];
+        right[n - 1] = n;
+        for (int i = n - 2; i >= 0; i--) {
+            int p = i + 1;
+            while (p < n && nums[p] >= nums[i]) {
+                p = right[p];
+            }
+            right[i] = p;
+        }
+        long res = 0L;
+        long[] preSum = new long[n];
+        preSum[0] = nums[0];
+        for (int i = 1; i < n; i++) {
+            preSum[i] = preSum[i - 1] + nums[i];
+        }
+        for (int i = 0; i < n; i++) {
+            long sum =
+                    left[i] == -1 ? preSum[right[i] - 1] : preSum[right[i] - 1] - preSum[left[i]];
+            long cur = nums[i] * sum;
+            res = Math.max(cur, res);
+        }
+        return (int) (res % mod);
+    }
+}

src/main/java/g1801_1900/s1856_maximum_subarray_min_product/readme.md

@@ -0,0 +1,42 @@
+1856\. Maximum Subarray Min-Product
+
+Medium
+
+The **min-product** of an array is equal to the **minimum value** in the array **multiplied by** the array's **sum**.
+
+*   For example, the array `[3,2,5]` (minimum value is `2`) has a min-product of `2 * (3+2+5) = 2 * 10 = 20`.
+
+Given an array of integers `nums`, return _the **maximum min-product** of any **non-empty subarray** of_ `nums`. Since the answer may be large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+Note that the min-product should be maximized **before** performing the modulo operation. Testcases are generated such that the maximum min-product **without** modulo will fit in a **64-bit signed integer**.
+
+A **subarray** is a **contiguous** part of an array.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,2]
+
+**Output:** 14
+
+**Explanation:** The maximum min-product is achieved with the subarray [2,3,2] (minimum value is 2). 2 \* (2+3+2) = 2 \* 7 = 14.
+
+**Example 2:**
+
+**Input:** nums = [2,3,3,1,2]
+
+**Output:** 18
+
+**Explanation:** The maximum min-product is achieved with the subarray [3,3] (minimum value is 3). 3 \* (3+3) = 3 \* 6 = 18.
+
+**Example 3:**
+
+**Input:** nums = [3,1,5,6,4,2]
+
+**Output:** 60
+
+**Explanation:** The maximum min-product is achieved with the subarray [5,6,4] (minimum value is 4). 4 \* (5+6+4) = 4 \* 15 = 60.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>7</sup></code>

src/main/java/g1801_1900/s1857_largest_color_value_in_a_directed_graph/Solution.java

@@ -0,0 +1,93 @@
+package g1801_1900.s1857_largest_color_value_in_a_directed_graph;
+
+// #Hard #Hash_Table #Dynamic_Programming #Graph #Counting #Memoization #Topological_Sort
+// #2022_05_08_Time_110_ms_(73.53%)_Space_108.2_MB_(86.97%)
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+
+public class Solution {
+    public int largestPathValue(String colors, int[][] edges) {
+        int len = colors.length();
+        List<Integer>[] graph = buildGraph(len, edges);
+
+        int[] frequencies = new int[26];
+        HashMap<Integer, int[]> calculatedFrequencies = new HashMap<>();
+        int[] status = new int[len];
+        for (int i = 0; i < len; i++) {
+            if (status[i] != 0) {
+                continue;
+            }
+            int[] localMax = runDFS(graph, i, calculatedFrequencies, status, colors);
+
+            if (localMax[26] == -1) {
+                Arrays.fill(frequencies, -1);
+                break;
+            } else {
+                for (int color = 0; color < 26; color++) {
+                    frequencies[color] = Math.max(frequencies[color], localMax[color]);
+                }
+            }
+        }
+
+        int max = Integer.MIN_VALUE;
+        for (int freq : frequencies) {
+            max = Math.max(max, freq);
+        }
+
+        return max;
+    }
+
+    private int[] runDFS(
+            List<Integer>[] graph,
+            int node,
+            HashMap<Integer, int[]> calculatedFrequencies,
+            int[] status,
+            String colors) {
+        if (calculatedFrequencies.containsKey(node)) {
+            return calculatedFrequencies.get(node);
+        }
+
+        int[] frequencies = new int[27];
+        if (status[node] == 1) {
+            frequencies[26] = -1;
+            return frequencies;
+        }
+
+        status[node] = 1;
+        for (int neighbour : graph[node]) {
+            int[] localMax = runDFS(graph, neighbour, calculatedFrequencies, status, colors);
+
+            if (localMax[26] == -1) {
+                return localMax;
+            }
+
+            for (int i = 0; i < 26; i++) {
+                frequencies[i] = Math.max(frequencies[i], localMax[i]);
+            }
+        }
+        status[node] = 2;
+
+        int color = colors.charAt(node) - 'a';
+        frequencies[color]++;
+
+        calculatedFrequencies.put(node, frequencies);
+
+        return frequencies;
+    }
+
+    private List<Integer>[] buildGraph(int n, int[][] edges) {
+        List<Integer>[] graph = new ArrayList[n];
+        for (int i = 0; i < n; i++) {
+            graph[i] = new ArrayList<>();
+        }
+
+        for (int[] edge : edges) {
+            graph[edge[0]].add(edge[1]);
+        }
+
+        return graph;
+    }
+}

src/main/java/g1801_1900/s1857_largest_color_value_in_a_directed_graph/readme.md

@@ -0,0 +1,40 @@
+1857\. Largest Color Value in a Directed Graph
+
+Hard
+
+There is a **directed graph** of `n` colored nodes and `m` edges. The nodes are numbered from `0` to `n - 1`.
+
+You are given a string `colors` where `colors[i]` is a lowercase English letter representing the **color** of the <code>i<sup>th</sup></code> node in this graph (**0-indexed**). You are also given a 2D array `edges` where <code>edges[j] = [a<sub>j</sub>, b<sub>j</sub>]</code> indicates that there is a **directed edge** from node <code>a<sub>j</sub></code> to node <code>b<sub>j</sub></code>.
+
+A valid **path** in the graph is a sequence of nodes <code>x<sub>1</sub> -> x<sub>2</sub> -> x<sub>3</sub> -> ... -> x<sub>k</sub></code> such that there is a directed edge from <code>x<sub>i</sub></code> to <code>x<sub>i+1</sub></code> for every `1 <= i < k`. The **color value** of the path is the number of nodes that are colored the **most frequently** occurring color along that path.
+
+Return _the **largest color value** of any valid path in the given graph, or_ `-1` _if the graph contains a cycle_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/04/21/leet1.png)
+
+**Input:** colors = "abaca", edges = [[0,1],[0,2],[2,3],[3,4]]
+
+**Output:** 3
+
+**Explanation:** The path 0 -> 2 -> 3 -> 4 contains 3 nodes that are colored `"a" (red in the above image)`.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/04/21/leet2.png)
+
+**Input:** colors = "a", edges = [[0,0]]
+
+**Output:** -1
+
+**Explanation:** There is a cycle from 0 to 0.
+
+**Constraints:**
+
+*   `n == colors.length`
+*   `m == edges.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>0 <= m <= 10<sup>5</sup></code>
+*   `colors` consists of lowercase English letters.
+*   <code>0 <= a<sub>j</sub>, b<sub>j</sub> < n</code>

src/main/java/g1801_1900/s1859_sorting_the_sentence/Solution.java

@@ -0,0 +1,23 @@
+package g1801_1900.s1859_sorting_the_sentence;
+
+// #Easy #String #Sorting #2022_05_08_Time_2_ms_(50.32%)_Space_42_MB_(55.85%)
+
+import java.util.Map;
+import java.util.TreeMap;
+
+public class Solution {
+    public String sortSentence(String s) {
+        String[] words = s.split(" ");
+        TreeMap<Integer, String> treeMap = new TreeMap<>();
+        for (String word : words) {
+            int key = Integer.parseInt(word.charAt(word.length() - 1) + "");
+            treeMap.put(key, word.substring(0, word.length() - 1));
+        }
+        StringBuilder sb = new StringBuilder();
+        for (Map.Entry<Integer, String> entry : treeMap.entrySet()) {
+            sb.append(entry.getValue());
+            sb.append(" ");
+        }
+        return sb.substring(0, sb.length() - 1);
+    }
+}

src/main/java/g1801_1900/s1859_sorting_the_sentence/readme.md

@@ -0,0 +1,35 @@
+1859\. Sorting the Sentence
+
+Easy
+
+A **sentence** is a list of words that are separated by a single space with no leading or trailing spaces. Each word consists of lowercase and uppercase English letters.
+
+A sentence can be **shuffled** by appending the **1-indexed word position** to each word then rearranging the words in the sentence.
+
+*   For example, the sentence `"This is a sentence"` can be shuffled as `"sentence4 a3 is2 This1"` or `"is2 sentence4 This1 a3"`.
+
+Given a **shuffled sentence** `s` containing no more than `9` words, reconstruct and return _the original sentence_.
+
+**Example 1:**
+
+**Input:** s = "is2 sentence4 This1 a3"
+
+**Output:** "This is a sentence"
+
+**Explanation:** Sort the words in s to their original positions "This1 is2 a3 sentence4", then remove the numbers.
+
+**Example 2:**
+
+**Input:** s = "Myself2 Me1 I4 and3"
+
+**Output:** "Me Myself and I"
+
+**Explanation:** Sort the words in s to their original positions "Me1 Myself2 and3 I4", then remove the numbers.
+
+**Constraints:**
+
+*   `2 <= s.length <= 200`
+*   `s` consists of lowercase and uppercase English letters, spaces, and digits from `1` to `9`.
+*   The number of words in `s` is between `1` and `9`.
+*   The words in `s` are separated by a single space.
+*   `s` contains no leading or trailing spaces.

src/main/java/g1801_1900/s1860_incremental_memory_leak/Solution.java

@@ -0,0 +1,18 @@
+package g1801_1900.s1860_incremental_memory_leak;
+
+// #Medium #Simulation #2022_05_08_Time_5_ms_(78.57%)_Space_41.9_MB_(34.69%)
+
+public class Solution {
+    public int[] memLeak(int memory1, int memory2) {
+        int time = 1;
+        while (memory1 >= time || memory2 >= time) {
+            if (memory1 >= memory2) {
+                memory1 -= time;
+            } else {
+                memory2 -= time;
+            }
+            time++;
+        }
+        return new int[] {time, memory1, memory2};
+    }
+}