Added tasks 2830-2835

Author: ThanhNIT

src/main/java/g2801_2900/s2830_maximize_the_profit_as_the_salesman/Solution.java

@@ -0,0 +1,40 @@
+package g2801_2900.s2830_maximize_the_profit_as_the_salesman;
+
+// #Medium #Array #Dynamic_Programming #Sorting #Binary_Search
+// #2023_12_11_Time_36_ms_(80.00%)_Space_76.3_MB_(73.13%)
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class Solution {
+    public int maximizeTheProfit(int n, List<List<Integer>> offers) {
+        int[] dp = new int[n];
+        HashMap<Integer, List<List<Integer>>> range = new HashMap<>();
+        for (List<Integer> l : offers) {
+            if (range.containsKey(l.get(0))) {
+                range.get(l.get(0)).add(l);
+            } else {
+                List<List<Integer>> r = new ArrayList<>();
+                r.add(l);
+                range.put(l.get(0), r);
+            }
+        }
+        int i = 0;
+        while (i < n) {
+            List<List<Integer>> temp = new ArrayList<>();
+            if (range.containsKey(i)) {
+                temp = range.get(i);
+            }
+            dp[i] = (i != 0) ? Math.max(dp[i], dp[i - 1]) : dp[i];
+            for (List<Integer> l : temp) {
+                dp[l.get(1)] =
+                        (i != 0)
+                                ? Math.max(dp[l.get(1)], dp[i - 1] + l.get(2))
+                                : Math.max(dp[l.get(1)], l.get(2));
+            }
+            i++;
+        }
+        return dp[n - 1];
+    }
+}

src/main/java/g2801_2900/s2830_maximize_the_profit_as_the_salesman/readme.md

@@ -0,0 +1,45 @@
+2830\. Maximize the Profit as the Salesman
+
+Medium
+
+You are given an integer `n` representing the number of houses on a number line, numbered from `0` to `n - 1`.
+
+Additionally, you are given a 2D integer array `offers` where <code>offers[i] = [start<sub>i</sub>, end<sub>i</sub>, gold<sub>i</sub>]</code>, indicating that <code>i<sup>th</sup></code> buyer wants to buy all the houses from <code>start<sub>i</sub></code> to <code>end<sub>i</sub></code> for <code>gold<sub>i</sub></code> amount of gold.
+
+As a salesman, your goal is to **maximize** your earnings by strategically selecting and selling houses to buyers.
+
+Return _the maximum amount of gold you can earn_.
+
+**Note** that different buyers can't buy the same house, and some houses may remain unsold.
+
+**Example 1:**
+
+**Input:** n = 5, offers = [[0,0,1],[0,2,2],[1,3,2]]
+
+**Output:** 3
+
+**Explanation:** There are 5 houses numbered from 0 to 4 and there are 3 purchase offers. 
+
+We sell houses in the range [0,0] to 1<sup>st</sup> buyer for 1 gold and houses in the range [1,3] to 3<sup>rd</sup> buyer for 2 golds. 
+
+It can be proven that 3 is the maximum amount of gold we can achieve.
+
+**Example 2:**
+
+**Input:** n = 5, offers = [[0,0,1],[0,2,10],[1,3,2]]
+
+**Output:** 10
+
+**Explanation:** There are 5 houses numbered from 0 to 4 and there are 3 purchase offers. 
+
+We sell houses in the range [0,2] to 2<sup>nd</sup> buyer for 10 golds. 
+
+It can be proven that 10 is the maximum amount of gold we can achieve.
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>1 <= offers.length <= 10<sup>5</sup></code>
+*   `offers[i].length == 3`
+*   <code>0 <= start<sub>i</sub> <= end<sub>i</sub> <= n - 1</code>
+*   <code>1 <= gold<sub>i</sub> <= 10<sup>3</sup></code>

src/main/java/g2801_2900/s2831_find_the_longest_equal_subarray/Solution.java

@@ -0,0 +1,23 @@
+package g2801_2900.s2831_find_the_longest_equal_subarray;
+
+// #Medium #Array #Hash_Table #Binary_Search #Sliding_Window
+// #2023_12_11_Time_15_ms_(96.81%)_Space_57.6_MB_(92.02%)
+
+import java.util.List;
+
+public class Solution {
+    public int longestEqualSubarray(List<Integer> nums, int k) {
+        int[] count = new int[nums.size() + 1];
+        int i = 0;
+        int maxCount = 0;
+        for (int j = 0; j < nums.size(); j++) {
+            count[nums.get(j)]++;
+            maxCount = Math.max(maxCount, count[nums.get(j)]);
+            if ((j - i + 1) - maxCount > k) {
+                count[nums.get(i)]--;
+                i++;
+            }
+        }
+        return maxCount;
+    }
+}

src/main/java/g2801_2900/s2831_find_the_longest_equal_subarray/readme.md

@@ -0,0 +1,41 @@
+2831\. Find the Longest Equal Subarray
+
+Medium
+
+You are given a **0-indexed** integer array `nums` and an integer `k`.
+
+A subarray is called **equal** if all of its elements are equal. Note that the empty subarray is an **equal** subarray.
+
+Return _the length of the **longest** possible equal subarray after deleting **at most**_ `k` _elements from_ `nums`.
+
+A **subarray** is a contiguous, possibly empty sequence of elements within an array.
+
+**Example 1:**
+
+**Input:** nums = [1,3,2,3,1,3], k = 3
+
+**Output:** 3
+
+**Explanation:** It's optimal to delete the elements at index 2 and index 4. 
+
+After deleting them, nums becomes equal to [1, 3, 3, 3]. The longest equal subarray starts at i = 1 and ends at j = 3 with length equal to 3. 
+
+It can be proven that no longer equal subarrays can be created.
+
+**Example 2:**
+
+**Input:** nums = [1,1,2,2,1,1], k = 2
+
+**Output:** 4
+
+**Explanation:** It's optimal to delete the elements at index 2 and index 3.
+
+After deleting them, nums becomes equal to [1, 1, 1, 1]. The array itself is an equal subarray, so the answer is 4. 
+
+It can be proven that no longer equal subarrays can be created.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   `1 <= nums[i] <= nums.length`
+*   `0 <= k <= nums.length`

src/main/java/g2801_2900/s2833_furthest_point_from_origin/Solution.java

@@ -0,0 +1,20 @@
+package g2801_2900.s2833_furthest_point_from_origin;
+
+// #Easy #Array #Counting #2023_12_11_Time_1_ms_(100.00%)_Space_41.4_MB_(50.89%)
+
+public class Solution {
+    public int furthestDistanceFromOrigin(String m) {
+        int count = 0;
+        int res = 0;
+        for (int i = 0; i < m.length(); i++) {
+            if (m.charAt(i) == 'L') {
+                res -= 1;
+            } else if (m.charAt(i) == 'R') {
+                res += 1;
+            } else {
+                count++;
+            }
+        }
+        return Math.abs(res) + count;
+    }
+}

src/main/java/g2801_2900/s2833_furthest_point_from_origin/readme.md

@@ -0,0 +1,41 @@
+2833\. Furthest Point From Origin
+
+Easy
+
+You are given a string `moves` of length `n` consisting only of characters `'L'`, `'R'`, and `'_'`. The string represents your movement on a number line starting from the origin `0`.
+
+In the <code>i<sup>th</sup></code> move, you can choose one of the following directions:
+
+*   move to the left if `moves[i] = 'L'` or `moves[i] = '_'`
+*   move to the right if `moves[i] = 'R'` or `moves[i] = '_'`
+
+Return _the **distance from the origin** of the **furthest** point you can get to after_ `n` _moves_.
+
+**Example 1:**
+
+**Input:** moves = "L\_RL\_\_R"
+
+**Output:** 3
+
+**Explanation:** The furthest point we can reach from the origin 0 is point -3 through the following sequence of moves "LLRLLLR".
+
+**Example 2:**
+
+**Input:** moves = "\_R\_\_LL\_"
+
+**Output:** 5
+
+**Explanation:** The furthest point we can reach from the origin 0 is point -5 through the following sequence of moves "LRLLLLL".
+
+**Example 3:**
+
+**Input:** moves = "\_\_\_\_\_\_\_"
+
+**Output:** 7
+
+**Explanation:** The furthest point we can reach from the origin 0 is point 7 through the following sequence of moves "RRRRRRR".
+
+**Constraints:**
+
+*   `1 <= moves.length == n <= 50`
+*   `moves` consists only of characters `'L'`, `'R'` and `'_'`.

src/main/java/g2801_2900/s2834_find_the_minimum_possible_sum_of_a_beautiful_array/Solution.java

@@ -0,0 +1,16 @@
+package g2801_2900.s2834_find_the_minimum_possible_sum_of_a_beautiful_array;
+
+// #Medium #Math #Greedy #2023_12_11_Time_0_ms_(100.00%)_Space_39.6_MB_(48.53%)
+
+public class Solution {
+    public int minimumPossibleSum(int n, int k) {
+        long mod = (long) 1e9 + 7;
+        if (k > (n + n - 1)) {
+            return (int) ((long) n * (n + 1) % mod / 2);
+        }
+        long toChange = n - (long) (k / 2);
+        long sum = ((n * ((long) n + 1)) / 2) % mod;
+        long remain = (long) k - ((k / 2) + 1);
+        return (int) ((sum + (toChange * remain) % mod) % mod);
+    }
+}

src/main/java/g2801_2900/s2834_find_the_minimum_possible_sum_of_a_beautiful_array/readme.md

@@ -0,0 +1,52 @@
+2834\. Find the Minimum Possible Sum of a Beautiful Array
+
+Medium
+
+You are given positive integers `n` and `target`.
+
+An array `nums` is **beautiful** if it meets the following conditions:
+
+*   `nums.length == n`.
+*   `nums` consists of pairwise **distinct** **positive** integers.
+*   There doesn't exist two **distinct** indices, `i` and `j`, in the range `[0, n - 1]`, such that `nums[i] + nums[j] == target`.
+
+Return _the **minimum** possible sum that a beautiful array could have modulo_ <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** n = 2, target = 3
+
+**Output:** 4
+
+**Explanation:** We can see that nums = [1,3] is beautiful. 
+- The array nums has length n = 2. 
+- The array nums consists of pairwise distinct positive integers. 
+- There doesn't exist two distinct indices, i and j, with nums[i] + nums[j] == 3. 
+
+It can be proven that 4 is the minimum possible sum that a beautiful array could have.
+
+**Example 2:**
+
+**Input:** n = 3, target = 3
+
+**Output:** 8
+
+**Explanation:** We can see that nums = [1,3,4] is beautiful. 
+- The array nums has length n = 3. 
+- The array nums consists of pairwise distinct positive integers. 
+- There doesn't exist two distinct indices, i and j, with nums[i] + nums[j] == 3.
+
+It can be proven that 8 is the minimum possible sum that a beautiful array could have.
+
+**Example 3:**
+
+**Input:** n = 1, target = 1
+
+**Output:** 1
+
+**Explanation:** We can see, that nums = [1] is beautiful.
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>9</sup></code>
+*   <code>1 <= target <= 10<sup>9</sup></code>

src/main/java/g2801_2900/s2835_minimum_operations_to_form_subsequence_with_target_sum/Solution.java

@@ -0,0 +1,34 @@
+package g2801_2900.s2835_minimum_operations_to_form_subsequence_with_target_sum;
+
+// #Hard #Array #Greedy #Bit_Manipulation #2023_12_11_Time_2_ms_(94.66%)_Space_43.3_MB_(39.69%)
+
+import java.util.List;
+import java.util.PriorityQueue;
+
+public class Solution {
+    public int minOperations(List<Integer> nums, int target) {
+        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
+        long sum = 0;
+        long count = 0;
+        for (int x : nums) {
+            pq.offer(x);
+            sum += x;
+        }
+        if (sum < target) {
+            return -1;
+        }
+        while (!pq.isEmpty()) {
+            int val = pq.poll();
+            sum -= val;
+            if (val <= target) {
+                target -= val;
+            } else if (sum < target) {
+                count++;
+                pq.offer(val / 2);
+                pq.offer(val / 2);
+                sum += val;
+            }
+        }
+        return (int) count;
+    }
+}

src/main/java/g2801_2900/s2835_minimum_operations_to_form_subsequence_with_target_sum/readme.md

@@ -0,0 +1,56 @@
+2835\. Minimum Operations to Form Subsequence With Target Sum
+
+Hard
+
+You are given a **0-indexed** array `nums` consisting of **non-negative** powers of `2`, and an integer `target`.
+
+In one operation, you must apply the following changes to the array:
+
+*   Choose any element of the array `nums[i]` such that `nums[i] > 1`.
+*   Remove `nums[i]` from the array.
+*   Add **two** occurrences of `nums[i] / 2` to the **end** of `nums`.
+
+Return the _**minimum number of operations** you need to perform so that_ `nums` _contains a **subsequence** whose elements sum to_ `target`. If it is impossible to obtain such a subsequence, return `-1`.
+
+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 = [1,2,8], target = 7
+
+**Output:** 1
+
+**Explanation:** In the first operation, we choose element nums[2]. The array becomes equal to nums = [1,2,4,4]. 
+
+At this stage, nums contains the subsequence [1,2,4] which sums up to 7. 
+
+It can be shown that there is no shorter sequence of operations that results in a subsequnce that sums up to 7.
+
+**Example 2:**
+
+**Input:** nums = [1,32,1,2], target = 12
+
+**Output:** 2
+
+**Explanation:** In the first operation, we choose element nums[1]. The array becomes equal to nums = [1,1,2,16,16]. 
+
+In the second operation, we choose element nums[3]. The array becomes equal to nums = [1,1,2,16,8,8] 
+
+At this stage, nums contains the subsequence [1,1,2,8] which sums up to 12. 
+
+It can be shown that there is no shorter sequence of operations that results in a subsequence that sums up to 12.
+
+**Example 3:**
+
+**Input:** nums = [1,32,1], target = 35
+
+**Output:** -1
+
+**Explanation:** It can be shown that no sequence of operations results in a subsequence that sums up to 35.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   <code>1 <= nums[i] <= 2<sup>30</sup></code>
+*   `nums` consists only of non-negative powers of two.
+*   <code>1 <= target < 2<sup>31</sup></code>