Added tasks 2862-2867

Author: ThanhNIT

src/main/java/g2801_2900/s2862_maximum_element_sum_of_a_complete_subset_of_indices/Solution.java

@@ -0,0 +1,28 @@
+package g2801_2900.s2862_maximum_element_sum_of_a_complete_subset_of_indices;
+
+// #Hard #Array #Math #Number_Theory #2023_12_20_Time_3_ms_(78.95%)_Space_44.4_MB_(88.16%)
+
+import java.util.List;
+
+public class Solution {
+    public long maximumSum(List<Integer> nums) {
+        long ans = 0;
+        int n = nums.size();
+        int bound = (int) Math.floor(Math.sqrt(n));
+        int[] squares = new int[bound + 1];
+        for (int i = 1; i <= bound + 1; i++) {
+            squares[i - 1] = i * i;
+        }
+        for (int i = 1; i <= n; i++) {
+            long res = 0;
+            int idx = 0;
+            int curr = i * squares[idx];
+            while (curr <= n) {
+                res += nums.get(curr - 1);
+                curr = i * squares[++idx];
+            }
+            ans = Math.max(ans, res);
+        }
+        return ans;
+    }
+}

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

@@ -0,0 +1,52 @@
+2862\. Maximum Element-Sum of a Complete Subset of Indices
+
+Hard
+
+You are given a **1****\-indexed** array `nums` of `n` integers.
+
+A set of numbers is **complete** if the product of every pair of its elements is a perfect square.
+
+For a subset of the indices set `{1, 2, ..., n}` represented as <code>{i<sub>1</sub>, i<sub>2</sub>, ..., i<sub>k</sub>}</code>, we define its **element-sum** as: <code>nums[i<sub>1</sub>] + nums[i<sub>2</sub>] + ... + nums[i<sub>k</sub>]</code>.
+
+Return _the **maximum element-sum** of a **complete** subset of the indices set_ `{1, 2, ..., n}`.
+
+A perfect square is a number that can be expressed as the product of an integer by itself.
+
+**Example 1:**
+
+**Input:** nums = [8,7,3,5,7,2,4,9]
+
+**Output:** 16
+
+**Explanation:** Apart from the subsets consisting of a single index, there are two other complete subsets of indices: {1,4} and {2,8}. 
+
+The sum of the elements corresponding to indices 1 and 4 is equal to nums[1] + nums[4] = 8 + 5 = 13. 
+
+The sum of the elements corresponding to indices 2 and 8 is equal to nums[2] + nums[8] = 7 + 9 = 16.
+
+Hence, the maximum element-sum of a complete subset of indices is 16.
+
+**Example 2:**
+
+**Input:** nums = [5,10,3,10,1,13,7,9,4]
+
+**Output:** 19
+
+**Explanation:** Apart from the subsets consisting of a single index, there are four other complete subsets of indices: {1,4}, {1,9}, {2,8}, {4,9}, and {1,4,9}. 
+
+The sum of the elements corresponding to indices 1 and 4 is equal to nums[1] + nums[4] = 5 + 10 = 15. 
+
+The sum of the elements corresponding to indices 1 and 9 is equal to nums[1] + nums[9] = 5 + 4 = 9. 
+
+The sum of the elements corresponding to indices 2 and 8 is equal to nums[2] + nums[8] = 10 + 9 = 19. 
+
+The sum of the elements corresponding to indices 4 and 9 is equal to nums[4] + nums[9] = 10 + 4 = 14. 
+
+The sum of the elements corresponding to indices 1, 4, and 9 is equal to nums[1] + nums[4] + nums[9] = 5 + 10 + 4 = 19. 
+
+Hence, the maximum element-sum of a complete subset of indices is 19.
+
+**Constraints:**
+
+*   <code>1 <= n == nums.length <= 10<sup>4</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>

src/main/java/g2801_2900/s2864_maximum_odd_binary_number/Solution.java

@@ -0,0 +1,30 @@
+package g2801_2900.s2864_maximum_odd_binary_number;
+
+// #Easy #String #Math #Greedy #2023_12_20_Time_1_ms_(100.00%)_Space_41.8_MB_(93.74%)
+
+public class Solution {
+    public String maximumOddBinaryNumber(String s) {
+        int len = s.length();
+        int count = 0;
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < len; i++) {
+            if (s.charAt(i) == '1') {
+                count++;
+            }
+        }
+        if (count == len) {
+            return s;
+        }
+        len -= count;
+        while (count > 1) {
+            sb.append('1');
+            count--;
+        }
+        while (len > 0) {
+            sb.append('0');
+            len--;
+        }
+        sb.append('1');
+        return sb.toString();
+    }
+}

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

@@ -0,0 +1,33 @@
+2864\. Maximum Odd Binary Number
+
+Easy
+
+You are given a **binary** string `s` that contains at least one `'1'`.
+
+You have to **rearrange** the bits in such a way that the resulting binary number is the **maximum odd binary number** that can be created from this combination.
+
+Return _a string representing the maximum odd binary number that can be created from the given combination._
+
+**Note** that the resulting string **can** have leading zeros.
+
+**Example 1:**
+
+**Input:** s = "010"
+
+**Output:** "001"
+
+**Explanation:** Because there is just one '1', it must be in the last position. So the answer is "001".
+
+**Example 2:**
+
+**Input:** s = "0101"
+
+**Output:** "1001"
+
+**Explanation:** One of the '1's must be in the last position. The maximum number that can be made with the remaining digits is "100". So the answer is "1001".
+
+**Constraints:**
+
+*   `1 <= s.length <= 100`
+*   `s` consists only of `'0'` and `'1'`.
+*   `s` contains at least one `'1'`.

src/main/java/g2801_2900/s2865_beautiful_towers_i/Solution.java

@@ -0,0 +1,36 @@
+package g2801_2900.s2865_beautiful_towers_i;
+
+// #Medium #Array #Stack #Monotonic_Stack #2023_12_20_Time_13_ms_(74.26%)_Space_43.4_MB_(45.54%)
+
+import java.util.List;
+
+public class Solution {
+    private long fun(List<Integer> maxHeights, int pickId) {
+        long ans = maxHeights.get(pickId);
+        long min = maxHeights.get(pickId);
+        for (int i = pickId - 1; i >= 0; i--) {
+            min = Math.min(min, maxHeights.get(i));
+            ans += min;
+        }
+        min = maxHeights.get(pickId);
+        for (int i = pickId + 1; i < maxHeights.size(); i++) {
+            min = Math.min(min, maxHeights.get(i));
+            ans += min;
+        }
+        return ans;
+    }
+
+    public long maximumSumOfHeights(List<Integer> maxHeights) {
+        int n = maxHeights.size();
+        long ans = 0;
+        for (int i = 0; i < n; i++) {
+            if (i == 0
+                    || i == n - 1
+                    || (maxHeights.get(i) >= maxHeights.get(i - 1)
+                            && maxHeights.get(i) >= maxHeights.get(i + 1))) {
+                ans = Math.max(ans, fun(maxHeights, i));
+            }
+        }
+        return ans;
+    }
+}

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

@@ -0,0 +1,60 @@
+2865\. Beautiful Towers I
+
+Medium
+
+You are given a **0-indexed** array `maxHeights` of `n` integers.
+
+You are tasked with building `n` towers in the coordinate line. The <code>i<sup>th</sup></code> tower is built at coordinate `i` and has a height of `heights[i]`.
+
+A configuration of towers is **beautiful** if the following conditions hold:
+
+1.  `1 <= heights[i] <= maxHeights[i]`
+2.  `heights` is a **mountain** array.
+
+Array `heights` is a **mountain** if there exists an index `i` such that:
+
+*   For all `0 < j <= i`, `heights[j - 1] <= heights[j]`
+*   For all `i <= k < n - 1`, `heights[k + 1] <= heights[k]`
+
+Return _the **maximum possible sum of heights** of a beautiful configuration of towers_.
+
+**Example 1:**
+
+**Input:** maxHeights = [5,3,4,1,1]
+
+**Output:** 13
+
+**Explanation:** One beautiful configuration with a maximum sum is heights = [5,3,3,1,1]. This configuration is beautiful since: 
+- 1 <= heights[i] <= maxHeights[i] 
+- heights is a mountain of peak i = 0.
+
+It can be shown that there exists no other beautiful configuration with a sum of heights greater than 13.
+
+**Example 2:**
+
+**Input:** maxHeights = [6,5,3,9,2,7]
+
+**Output:** 22
+
+**Explanation:** One beautiful configuration with a maximum sum is heights = [3,3,3,9,2,2]. This configuration is beautiful since: 
+- 1 <= heights[i] <= maxHeights[i] 
+- heights is a mountain of peak i = 3. 
+
+It can be shown that there exists no other beautiful configuration with a sum of heights greater than 22.
+
+**Example 3:**
+
+**Input:** maxHeights = [3,2,5,5,2,3]
+
+**Output:** 18
+
+**Explanation:** One beautiful configuration with a maximum sum is heights = [2,2,5,5,2,2]. This configuration is beautiful since: 
+- 1 <= heights[i] <= maxHeights[i] 
+- heights is a mountain of peak i = 2.
+
+Note that, for this configuration, i = 3 can also be considered a peak. It can be shown that there exists no other beautiful configuration with a sum of heights greater than 18.
+
+**Constraints:**
+
+*   <code>1 <= n == maxHeights <= 10<sup>3</sup></code>
+*   <code>1 <= maxHeights[i] <= 10<sup>9</sup></code>

src/main/java/g2801_2900/s2866_beautiful_towers_ii/Solution.java

@@ -0,0 +1,65 @@
+package g2801_2900.s2866_beautiful_towers_ii;
+
+// #Medium #Array #Stack #Monotonic_Stack #2023_12_20_Time_35_ms_(89.02%)_Space_72.5_MB_(5.49%)
+
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.List;
+
+public class Solution {
+    public long maximumSumOfHeights(List<Integer> mH) {
+        int n = mH.size();
+        Deque<Integer> st = new LinkedList<>();
+        int[] prevSmaller = new int[n + 1];
+        for (int i = 0; i < n; i++) {
+            while (!st.isEmpty() && mH.get(st.peek()) >= mH.get(i)) {
+                st.pop();
+            }
+            if (st.isEmpty()) {
+                prevSmaller[i] = -1;
+            } else {
+                prevSmaller[i] = st.peek();
+            }
+            st.push(i);
+        }
+        st.clear();
+        int[] nextSmaller = new int[n + 1];
+        for (int i = n - 1; i >= 0; i--) {
+            while (!st.isEmpty() && mH.get(st.peek()) >= mH.get(i)) {
+                st.pop();
+            }
+            if (st.isEmpty()) {
+                nextSmaller[i] = n;
+            } else {
+                nextSmaller[i] = st.peek();
+            }
+            st.push(i);
+        }
+        long[] leftSum = new long[n];
+        leftSum[0] = mH.get(0);
+        for (int i = 1; i < n; ++i) {
+            int prevSmallerIdx = prevSmaller[i];
+            int equalCount = i - prevSmallerIdx;
+            leftSum[i] = ((long) equalCount * mH.get(i));
+            if (prevSmallerIdx != -1) {
+                leftSum[i] += leftSum[prevSmallerIdx];
+            }
+        }
+        long[] rightSum = new long[n];
+        rightSum[n - 1] = mH.get(n - 1);
+        for (int i = n - 2; i >= 0; i--) {
+            int nextSmallerIdx = nextSmaller[i];
+            int equalCount = nextSmallerIdx - i;
+            rightSum[i] = ((long) equalCount * mH.get(i));
+            if (nextSmallerIdx != n) {
+                rightSum[i] += rightSum[nextSmallerIdx];
+            }
+        }
+        long ans = 0;
+        for (int i = 0; i < n; i++) {
+            long totalSum = leftSum[i] + rightSum[i] - mH.get(i);
+            ans = Math.max(ans, totalSum);
+        }
+        return ans;
+    }
+}

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

@@ -0,0 +1,60 @@
+2866\. Beautiful Towers II
+
+Medium
+
+You are given a **0-indexed** array `maxHeights` of `n` integers.
+
+You are tasked with building `n` towers in the coordinate line. The <code>i<sup>th</sup></code> tower is built at coordinate `i` and has a height of `heights[i]`.
+
+A configuration of towers is **beautiful** if the following conditions hold:
+
+1.  `1 <= heights[i] <= maxHeights[i]`
+2.  `heights` is a **mountain** array.
+
+Array `heights` is a **mountain** if there exists an index `i` such that:
+
+*   For all `0 < j <= i`, `heights[j - 1] <= heights[j]`
+*   For all `i <= k < n - 1`, `heights[k + 1] <= heights[k]`
+
+Return _the **maximum possible sum of heights** of a beautiful configuration of towers_.
+
+**Example 1:**
+
+**Input:** maxHeights = [5,3,4,1,1]
+
+**Output:** 13
+
+**Explanation:** One beautiful configuration with a maximum sum is heights = [5,3,3,1,1]. This configuration is beautiful since: 
+- 1 <= heights[i] <= maxHeights[i] 
+- heights is a mountain of peak i = 0. 
+
+It can be shown that there exists no other beautiful configuration with a sum of heights greater than 13.
+
+**Example 2:**
+
+**Input:** maxHeights = [6,5,3,9,2,7]
+
+**Output:** 22
+
+**Explanation:** One beautiful configuration with a maximum sum is heights = [3,3,3,9,2,2]. This configuration is beautiful since: 
+- 1 <= heights[i] <= maxHeights[i] 
+- heights is a mountain of peak i = 3. 
+
+It can be shown that there exists no other beautiful configuration with a sum of heights greater than 22.
+
+**Example 3:**
+
+**Input:** maxHeights = [3,2,5,5,2,3]
+
+**Output:** 18
+
+**Explanation:** One beautiful configuration with a maximum sum is heights = [2,2,5,5,2,2]. This configuration is beautiful since: 
+- 1 <= heights[i] <= maxHeights[i] 
+- heights is a mountain of peak i = 2. 
+
+Note that, for this configuration, i = 3 can also be considered a peak. It can be shown that there exists no other beautiful configuration with a sum of heights greater than 18.
+
+**Constraints:**
+
+*   <code>1 <= n == maxHeights <= 10<sup>5</sup></code>
+*   <code>1 <= maxHeights[i] <= 10<sup>9</sup></code>