Added tasks 2536, 2537, 2538, 2540, 2541

Author: ThanhNIT

README.md

@@ -1848,6 +1848,11 @@ implementation 'com.github.javadev:leetcode-in-java:1.20'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2541 |[Minimum Operations to Make Array Equal II](src/main/java/g2501_2600/s2541_minimum_operations_to_make_array_equal_ii/Solution.java)| Medium | Array, Math, Greedy | 3 | 100.00
+| 2540 |[Minimum Common Value](src/main/java/g2501_2600/s2540_minimum_common_value/Solution.java)| Easy | Array, Hash_Table, Binary_Search, Two_Pointers | 0 | 100.00
+| 2538 |[Difference Between Maximum and Minimum Price Sum](src/main/java/g2501_2600/s2538_difference_between_maximum_and_minimum_price_sum/Solution.java)| Hard | Array, Dynamic_Programming, Tree, Depth_First_Search | 43 | 95.19
+| 2537 |[Count the Number of Good Subarrays](src/main/java/g2501_2600/s2537_count_the_number_of_good_subarrays/Solution.java)| Medium | Array, Hash_Table, Sliding_Window | 38 | 99.07
+| 2536 |[Increment Submatrices by One](src/main/java/g2501_2600/s2536_increment_submatrices_by_one/Solution.java)| Medium | Array, Matrix, Prefix_Sum | 12 | 88.15
 | 2535 |[Difference Between Element Sum and Digit Sum of an Array](src/main/java/g2501_2600/s2535_difference_between_element_sum_and_digit_sum_of_an_array/Solution.java)| Easy | Array, Math | 3 | 77.42
 | 2532 |[Time to Cross a Bridge](src/main/java/g2501_2600/s2532_time_to_cross_a_bridge/Solution.java)| Hard | Array, Heap_Priority_Queue, Simulation | 67 | 72.50
 | 2531 |[Make Number of Distinct Characters Equal](src/main/java/g2501_2600/s2531_make_number_of_distinct_characters_equal/Solution.java)| Medium | String, Hash_Table, Counting | 7 | 100.00

src/main/java/g2501_2600/s2536_increment_submatrices_by_one/Solution.java

@@ -0,0 +1,41 @@
+package g2501_2600.s2536_increment_submatrices_by_one;
+
+// #Medium #Array #Matrix #Prefix_Sum #2023_04_22_Time_12_ms_(88.15%)_Space_50.9_MB_(65.40%)
+
+public class Solution {
+    public int[][] rangeAddQueries(int n, int[][] queries) {
+        int[][] g = new int[n][n];
+        for (int[] q : queries) {
+            int r1 = q[0];
+            int c1 = q[1];
+            int r2 = q[2];
+            int c2 = q[3];
+            g[r1][c1]++;
+            if (c2 < n - 1) {
+                g[r1][c2 + 1]--;
+            }
+            if (r2 < n - 1) {
+                g[r2 + 1][c1]--;
+            }
+            if (c2 < n - 1 && r2 < n - 1) {
+                g[r2 + 1][c2 + 1]++;
+            }
+        }
+
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (i > 0) {
+                    g[i][j] += g[i - 1][j];
+                }
+                if (j > 0) {
+                    g[i][j] += g[i][j - 1];
+                }
+                if (i > 0 && j > 0) {
+                    g[i][j] -= g[i - 1][j - 1];
+                }
+            }
+        }
+
+        return g;
+    }
+}

src/main/java/g2501_2600/s2536_increment_submatrices_by_one/readme.md

@@ -0,0 +1,44 @@
+2536\. Increment Submatrices by One
+
+Medium
+
+You are given a positive integer `n`, indicating that we initially have an `n x n` **0-indexed** integer matrix `mat` filled with zeroes.
+
+You are also given a 2D integer array `query`. For each <code>query[i] = [row1<sub>i</sub>, col1<sub>i</sub>, row2<sub>i</sub>, col2<sub>i</sub>]</code>, you should do the following operation:
+
+*   Add `1` to **every element** in the submatrix with the **top left** corner <code>(row1<sub>i</sub>, col1<sub>i</sub>)</code> and the **bottom right** corner <code>(row2<sub>i</sub>, col2<sub>i</sub>)</code>. That is, add `1` to `mat[x][y]` for all <code>row1<sub>i</sub> <= x <= row2<sub>i</sub></code> and <code>col1<sub>i</sub> <= y <= col2<sub>i</sub></code>.
+
+Return _the matrix_ `mat` _after performing every query._
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/11/24/p2example11.png)
+
+**Input:** n = 3, queries = [[1,1,2,2],[0,0,1,1]]
+
+**Output:** [[1,1,0],[1,2,1],[0,1,1]]
+
+**Explanation:** The diagram above shows the initial matrix, the matrix after the first query, and the matrix after the second query. 
+
+- In the first query, we add 1 to every element in the submatrix with the top left corner (1, 1) and bottom right corner (2, 2). 
+
+- In the second query, we add 1 to every element in the submatrix with the top left corner (0, 0) and bottom right corner (1, 1).
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/11/24/p2example22.png)
+
+**Input:** n = 2, queries = [[0,0,1,1]]
+
+**Output:** [[1,1],[1,1]]
+
+**Explanation:** The diagram above shows the initial matrix and the matrix after the first query. 
+
+- In the first query we add 1 to every element in the matrix.
+
+**Constraints:**
+
+*   `1 <= n <= 500`
+*   <code>1 <= queries.length <= 10<sup>4</sup></code>
+*   <code>0 <= row1<sub>i</sub> <= row2<sub>i</sub> < n</code>
+*   <code>0 <= col1<sub>i</sub> <= col2<sub>i</sub> < n</code>

src/main/java/g2501_2600/s2537_count_the_number_of_good_subarrays/Solution.java

@@ -0,0 +1,53 @@
+package g2501_2600.s2537_count_the_number_of_good_subarrays;
+
+// #Medium #Array #Hash_Table #Sliding_Window #2023_04_22_Time_38_ms_(99.07%)_Space_60.8_MB_(16.67%)
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Solution {
+    public long countGood(int[] nums, int k) {
+        if (nums.length < 2) {
+            return 0L;
+        }
+
+        Map<Integer, Integer> countMap = new HashMap<>(nums.length, 0.99f);
+        long goodSubArrays = 0L;
+        long current = 0L;
+        int left = 0;
+        int right = -1;
+        while (left < nums.length) {
+            if (current < k) {
+                if (++right == nums.length) {
+                    break;
+                }
+                Integer num = nums[right];
+                Integer count = countMap.get(num);
+                if (count == null) {
+                    count = 1;
+                } else {
+                    current += count;
+                    if (current >= k) {
+                        goodSubArrays += nums.length - right;
+                    }
+                    count = count + 1;
+                }
+                countMap.put(num, count);
+            } else {
+                Integer num = nums[left++];
+                int count = countMap.get(num) - 1;
+                if (count > 0) {
+                    countMap.put(num, count);
+                    current -= count;
+                } else {
+                    countMap.remove(num);
+                }
+                if (current >= k) {
+                    goodSubArrays += nums.length - right;
+                }
+            }
+        }
+
+        return goodSubArrays;
+    }
+}

src/main/java/g2501_2600/s2537_count_the_number_of_good_subarrays/readme.md

@@ -0,0 +1,38 @@
+2537\. Count the Number of Good Subarrays
+
+Medium
+
+Given an integer array `nums` and an integer `k`, return _the number of **good** subarrays of_ `nums`.
+
+A subarray `arr` is **good** if it there are **at least** `k` pairs of indices `(i, j)` such that `i < j` and `arr[i] == arr[j]`.
+
+A **subarray** is a contiguous **non-empty** sequence of elements within an array.
+
+**Example 1:**
+
+**Input:** nums = [1,1,1,1,1], k = 10
+
+**Output:** 1
+
+**Explanation:** The only good subarray is the array nums itself.
+
+**Example 2:**
+
+**Input:** nums = [3,1,4,3,2,2,4], k = 2
+
+**Output:** 4
+
+**Explanation:** There are 4 different good subarrays: 
+
+- [3,1,4,3,2,2] that has 2 pairs.
+
+- [3,1,4,3,2,2,4] that has 3 pairs.
+
+- [1,4,3,2,2,4] that has 2 pairs. 
+
+- [4,3,2,2,4] that has 2 pairs.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i], k <= 10<sup>9</sup></code>

src/main/java/g2501_2600/s2538_difference_between_maximum_and_minimum_price_sum/Solution.java

@@ -0,0 +1,79 @@
+package g2501_2600.s2538_difference_between_maximum_and_minimum_price_sum;
+
+// #Hard #Array #Dynamic_Programming #Tree #Depth_First_Search
+// #2023_04_22_Time_43_ms_(95.19%)_Space_86.2_MB_(57.69%)
+
+import java.util.ArrayList;
+
+public class Solution {
+    private ArrayList<Integer>[] tree;
+    private int[] price;
+    private long res;
+    private boolean[] visited;
+
+    public long maxOutput(int n, int[][] edges, int[] price) {
+        if (n == 1) {
+            return 0;
+        }
+
+        this.price = price;
+        tree = new ArrayList[n];
+        for (int i = 0; i < n; i++) {
+            tree[i] = new ArrayList<>();
+        }
+        for (int[] e : edges) {
+            tree[e[0]].add(e[1]);
+            tree[e[1]].add(e[0]);
+        }
+
+        visited = new boolean[n];
+        visited[0] = true;
+        dfs(0);
+
+        return res;
+    }
+
+    // return long[]{longest path with leaf, longest path without leaf}
+    private long[] dfs(int node) {
+        if (tree[node].size() == 1 && node != 0) {
+            return new long[] {price[node], 0};
+        }
+        int i0 = -1;
+        int i1 = -1;
+        long l0 = 0;
+        long l1 = 0;
+        long s0 = 0;
+        long s1 = 0;
+        for (int child : tree[node]) {
+            if (visited[child]) {
+                continue;
+            }
+            visited[child] = true;
+            long[] sub = dfs(child);
+            if (sub[0] >= l0) {
+                s0 = l0;
+                l0 = sub[0];
+                i0 = child;
+            } else if (sub[0] > s0) {
+                s0 = sub[0];
+            }
+
+            if (sub[1] >= l1) {
+                s1 = l1;
+                l1 = sub[1];
+                i1 = child;
+            } else if (sub[1] > s1) {
+                s1 = sub[1];
+            }
+        }
+
+        if (s0 == 0) {
+            // only one child. case: example 2
+            res = Math.max(res, Math.max(l0, l1 + price[node]));
+        } else {
+            long path = i0 != i1 ? price[node] + l0 + l1 : price[node] + Math.max(l0 + s1, s0 + l1);
+            res = Math.max(res, path);
+        }
+        return new long[] {l0 + price[node], l1 + price[node]};
+    }
+}

src/main/java/g2501_2600/s2538_difference_between_maximum_and_minimum_price_sum/readme.md

@@ -0,0 +1,54 @@
+2538\. Difference Between Maximum and Minimum Price Sum
+
+Hard
+
+There exists an undirected and initially unrooted tree with `n` nodes indexed from `0` to `n - 1`. You are given the integer `n` and 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.
+
+Each node has an associated price. You are given an integer array `price`, where `price[i]` is the price of the <code>i<sup>th</sup></code> node.
+
+The **price sum** of a given path is the sum of the prices of all nodes lying on that path.
+
+The tree can be rooted at any node `root` of your choice. The incurred **cost** after choosing `root` is the difference between the maximum and minimum **price sum** amongst all paths starting at `root`.
+
+Return _the **maximum** possible **cost**_ _amongst all possible root choices_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/12/01/example14.png)
+
+**Input:** n = 6, edges = [[0,1],[1,2],[1,3],[3,4],[3,5]], price = [9,8,7,6,10,5]
+
+**Output:** 24
+
+**Explanation:** The diagram above denotes the tree after rooting it at node 2. The first part (colored in red) shows the path with the maximum price sum. The second part (colored in blue) shows the path with the minimum price sum. 
+
+- The first path contains nodes [2,1,3,4]: the prices are [7,8,6,10], and the sum of the prices is 31. 
+
+- The second path contains the node [2] with the price [7]. 
+
+The difference between the maximum and minimum price sum is 24. It can be proved that 24 is the maximum cost.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/11/24/p1_example2.png)
+
+**Input:** n = 3, edges = [[0,1],[1,2]], price = [1,1,1]
+
+**Output:** 2
+
+**Explanation:** The diagram above denotes the tree after rooting it at node 0. The first part (colored in red) shows the path with the maximum price sum. The second part (colored in blue) shows the path with the minimum price sum. 
+
+- The first path contains nodes [0,1,2]: the prices are [1,1,1], and the sum of the prices is 3.
+
+- The second path contains node [0] with a price [1]. 
+
+The difference between the maximum and minimum price sum is 2. It can be proved that 2 is the maximum cost.
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `edges.length == n - 1`
+*   <code>0 <= a<sub>i</sub>, b<sub>i</sub> <= n - 1</code>
+*   `edges` represents a valid tree.
+*   `price.length == n`
+*   <code>1 <= price[i] <= 10<sup>5</sup></code>

src/main/java/g2501_2600/s2540_minimum_common_value/Solution.java

@@ -0,0 +1,25 @@
+package g2501_2600.s2540_minimum_common_value;
+
+// #Easy #Array #Hash_Table #Binary_Search #Two_Pointers
+// #2023_04_22_Time_0_ms_(100.00%)_Space_58.9_MB_(33.19%)
+
+public class Solution {
+    public int getCommon(int[] nums1, int[] nums2) {
+        int i = 0;
+        int j = 0;
+        if (nums1[0] > nums2[nums2.length - 1] || nums1[nums1.length - 1] < nums2[0]) {
+            return -1;
+        }
+        while (i < nums1.length && j < nums2.length) {
+            if (nums1[i] == nums2[j]) {
+                return nums1[i];
+            }
+            if (nums1[i] > nums2[j]) {
+                j++;
+            } else {
+                i++;
+            }
+        }
+        return -1;
+    }
+}

src/main/java/g2501_2600/s2540_minimum_common_value/readme.md

@@ -0,0 +1,29 @@
+2540\. Minimum Common Value
+
+Easy
+
+Given two integer arrays `nums1` and `nums2`, sorted in non-decreasing order, return _the **minimum integer common** to both arrays_. If there is no common integer amongst `nums1` and `nums2`, return `-1`.
+
+Note that an integer is said to be **common** to `nums1` and `nums2` if both arrays have **at least one** occurrence of that integer.
+
+**Example 1:**
+
+**Input:** nums1 = [1,2,3], nums2 = [2,4]
+
+**Output:** 2
+
+**Explanation:** The smallest element common to both arrays is 2, so we return 2.
+
+**Example 2:**
+
+**Input:** nums1 = [1,2,3,6], nums2 = [2,3,4,5]
+
+**Output:** 2
+
+**Explanation:** There are two common elements in the array 2 and 3 out of which 2 is the smallest, so 2 is returned.
+
+**Constraints:**
+
+*   <code>1 <= nums1.length, nums2.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums1[i], nums2[j] <= 10<sup>9</sup></code>
+*   Both `nums1` and `nums2` are sorted in **non-decreasing** order.