Added tasks 3498-3501

Author: javadev

src/main/java/g3401_3500/s3498_reverse_degree_of_a_string/Solution.java

@@ -0,0 +1,13 @@
+package g3401_3500.s3498_reverse_degree_of_a_string;
+
+// #Easy #2025_03_30_Time_1_ms_(100.00%)_Space_43.05_MB_(100.00%)
+
+public class Solution {
+    public int reverseDegree(String s) {
+        int ans = 0;
+        for (int i = 0; i < s.length(); ++i) {
+            ans += (26 - (s.charAt(i) - 'a')) * (i + 1);
+        }
+        return ans;
+    }
+}

src/main/java/g3401_3500/s3498_reverse_degree_of_a_string/readme.md

@@ -0,0 +1,50 @@
+3498\. Reverse Degree of a String
+
+Easy
+
+Given a string `s`, calculate its **reverse degree**.
+
+The **reverse degree** is calculated as follows:
+
+1.  For each character, multiply its position in the _reversed_ alphabet (`'a'` = 26, `'b'` = 25, ..., `'z'` = 1) with its position in the string **(1-indexed)**.
+2.  Sum these products for all characters in the string.
+
+Return the **reverse degree** of `s`.
+
+**Example 1:**
+
+**Input:** s = "abc"
+
+**Output:** 148
+
+**Explanation:**
+
+| Letter  | Index in Reversed Alphabet | Index in String | Product |
+|---------|----------------------------|----------------|---------|
+| `'a'`   | 26                         | 1              | 26      |
+| `'b'`   | 25                         | 2              | 50      |
+| `'c'`   | 24                         | 3              | 72      |
+
+The reversed degree is `26 + 50 + 72 = 148`.
+
+**Example 2:**
+
+**Input:** s = "zaza"
+
+**Output:** 160
+
+**Explanation:**
+
+| Letter  | Index in Reversed Alphabet | Index in String | Product |
+|---------|----------------------------|----------------|---------|
+| `'z'`   | 1                          | 1              | 1       |
+| `'a'`   | 26                         | 2              | 52      |
+| `'z'`   | 1                          | 3              | 3       |
+| `'a'`   | 26                         | 4              | 104     |
+
+The reverse degree is `1 + 52 + 3 + 104 = 160`.
+
+**Constraints:**
+
+*   `1 <= s.length <= 1000`
+*   `s` contains only lowercase English letters.

src/main/java/g3401_3500/s3499_maximize_active_section_with_trade_i/Solution.java

@@ -0,0 +1,29 @@
+package g3401_3500.s3499_maximize_active_section_with_trade_i;
+
+// #Medium #2025_03_30_Time_55_ms_(100.00%)_Space_45.50_MB_(100.00%)
+
+public class Solution {
+    public int maxActiveSectionsAfterTrade(String s) {
+        int oneCount = 0;
+        int convertedOne = 0;
+        int curZeroCount = 0;
+        int lastZeroCount = 0;
+        for (int i = 0; i < s.length(); ++i) {
+            if (s.charAt(i) == '0') {
+                curZeroCount++;
+            } else {
+                if (curZeroCount != 0) {
+                    lastZeroCount = curZeroCount;
+                }
+                curZeroCount = 0;
+                oneCount++;
+            }
+            convertedOne = Math.max(convertedOne, curZeroCount + lastZeroCount);
+        }
+        // corner case
+        if (convertedOne == curZeroCount || convertedOne == lastZeroCount) {
+            return oneCount;
+        }
+        return oneCount + convertedOne;
+    }
+}

src/main/java/g3401_3500/s3499_maximize_active_section_with_trade_i/readme.md

@@ -0,0 +1,68 @@
+3499\. Maximize Active Section with Trade I
+
+Medium
+
+You are given a binary string `s` of length `n`, where:
+
+*   `'1'` represents an **active** section.
+*   `'0'` represents an **inactive** section.
+
+You can perform **at most one trade** to maximize the number of active sections in `s`. In a trade, you:
+
+*   Convert a contiguous block of `'1'`s that is surrounded by `'0'`s to all `'0'`s.
+*   Afterward, convert a contiguous block of `'0'`s that is surrounded by `'1'`s to all `'1'`s.
+
+Return the **maximum** number of active sections in `s` after making the optimal trade.
+
+**Note:** Treat `s` as if it is **augmented** with a `'1'` at both ends, forming `t = '1' + s + '1'`. The augmented `'1'`s **do not** contribute to the final count.
+
+**Example 1:**
+
+**Input:** s = "01"
+
+**Output:** 1
+
+**Explanation:**
+
+Because there is no block of `'1'`s surrounded by `'0'`s, no valid trade is possible. The maximum number of active sections is 1.
+
+**Example 2:**
+
+**Input:** s = "0100"
+
+**Output:** 4
+
+**Explanation:**
+
+*   String `"0100"` → Augmented to `"101001"`.
+*   Choose `"0100"`, convert <code>"10<ins>**1**</ins>001"</code> → <code>"1<ins>**0000**</ins>1"</code> → <code>"1<ins>**1111**</ins>1"</code>.
+*   The final string without augmentation is `"1111"`. The maximum number of active sections is 4.
+
+**Example 3:**
+
+**Input:** s = "1000100"
+
+**Output:** 7
+
+**Explanation:**
+
+*   String `"1000100"` → Augmented to `"110001001"`.
+*   Choose `"000100"`, convert <code>"11000<ins>**1**</ins>001"</code> → <code>"11<ins>**000000**</ins>1"</code> → <code>"11<ins>**111111**</ins>1"</code>.
+*   The final string without augmentation is `"1111111"`. The maximum number of active sections is 7.
+
+**Example 4:**
+
+**Input:** s = "01010"
+
+**Output:** 4
+
+**Explanation:**
+
+*   String `"01010"` → Augmented to `"1010101"`.
+*   Choose `"010"`, convert <code>"10<ins>**1**</ins>0101"</code> → <code>"1<ins>**000**</ins>101"</code> → <code>"1<ins>**111**</ins>101"</code>.
+*   The final string without augmentation is `"11110"`. The maximum number of active sections is 4.
+
+**Constraints:**
+
+*   <code>1 <= n == s.length <= 10<sup>5</sup></code>
+*   `s[i]` is either `'0'` or `'1'`

src/main/java/g3401_3500/s3500_minimum_cost_to_divide_array_into_subarrays/Solution.java

@@ -0,0 +1,69 @@
+package g3401_3500.s3500_minimum_cost_to_divide_array_into_subarrays;
+
+// #Hard #2025_03_30_Time_225_ms_(94.64%)_Space_62.54_MB_(58.93%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public long minimumCost(int[] nums, int[] cost, int k) {
+        int n = nums.length;
+        long[] prefixNums = new long[n];
+        long total = 0;
+        for (int i = 0; i < n; i++) {
+            total += nums[i];
+            prefixNums[i] = total;
+        }
+        long[] prefixCost = new long[n + 1];
+        total = 0;
+        for (int i = 0; i < n; i++) {
+            total += cost[i];
+            prefixCost[i + 1] = total;
+        }
+        long[][] memo = new long[n][n + 1];
+        for (long[] row : memo) {
+            Arrays.fill(row, -1);
+        }
+        int[] bestSplit = new int[n];
+        Arrays.fill(bestSplit, -1);
+        return rec(0, 1, nums, prefixNums, prefixCost, k, memo, bestSplit);
+    }
+
+    private long rec(
+            int index,
+            int i,
+            int[] nums,
+            long[] prefixNums,
+            long[] prefixCost,
+            int k,
+            long[][] memo,
+            int[] bestSplit) {
+        int n = nums.length;
+        if (index == n) {
+            return 0;
+        }
+        if (memo[index][i] != -1) {
+            return memo[index][i];
+        }
+        if (bestSplit[index] != -1) {
+            int j = bestSplit[index];
+            long val =
+                    (prefixNums[j] + (long) k * i) * (prefixCost[j + 1] - prefixCost[index])
+                            + rec(j + 1, i + 1, nums, prefixNums, prefixCost, k, memo, bestSplit);
+            return memo[index][i] = val;
+        }
+        long best = Long.MAX_VALUE;
+        int bestIndex = -1;
+        for (int j = index; j < n; j++) {
+            long val =
+                    (prefixNums[j] + (long) k * i) * (prefixCost[j + 1] - prefixCost[index])
+                            + rec(j + 1, i + 1, nums, prefixNums, prefixCost, k, memo, bestSplit);
+            if (val < best) {
+                best = val;
+                bestIndex = j;
+            }
+        }
+        bestSplit[index] = bestIndex;
+        memo[index][i] = best;
+        return best;
+    }
+}

src/main/java/g3401_3500/s3500_minimum_cost_to_divide_array_into_subarrays/readme.md

@@ -0,0 +1,47 @@
+3500\. Minimum Cost to Divide Array Into Subarrays
+
+Hard
+
+You are given two integer arrays, `nums` and `cost`, of the same size, and an integer `k`.
+
+You can divide `nums` into **non-empty subarrays**. The cost of the <code>i<sup>th</sup></code> subarray consisting of elements `nums[l..r]` is:
+
+*   `(nums[0] + nums[1] + ... + nums[r] + k * i) * (cost[l] + cost[l + 1] + ... + cost[r])`.
+
+**Note** that `i` represents the order of the subarray: 1 for the first subarray, 2 for the second, and so on.
+
+Return the **minimum** total cost possible from any valid division.
+
+**Example 1:**
+
+**Input:** nums = [3,1,4], cost = [4,6,6], k = 1
+
+**Output:** 110
+
+**Explanation:**
+
+The minimum total cost possible can be achieved by dividing `nums` into subarrays `[3, 1]` and `[4]`.
+
+*   The cost of the first subarray `[3,1]` is `(3 + 1 + 1 * 1) * (4 + 6) = 50`.
+*   The cost of the second subarray `[4]` is `(3 + 1 + 4 + 1 * 2) * 6 = 60`.
+
+**Example 2:**
+
+**Input:** nums = [4,8,5,1,14,2,2,12,1], cost = [7,2,8,4,2,2,1,1,2], k = 7
+
+**Output:** 985
+
+**Explanation:**
+
+The minimum total cost possible can be achieved by dividing `nums` into subarrays `[4, 8, 5, 1]`, `[14, 2, 2]`, and `[12, 1]`.
+
+*   The cost of the first subarray `[4, 8, 5, 1]` is `(4 + 8 + 5 + 1 + 7 * 1) * (7 + 2 + 8 + 4) = 525`.
+*   The cost of the second subarray `[14, 2, 2]` is `(4 + 8 + 5 + 1 + 14 + 2 + 2 + 7 * 2) * (2 + 2 + 1) = 250`.
+*   The cost of the third subarray `[12, 1]` is `(4 + 8 + 5 + 1 + 14 + 2 + 2 + 12 + 1 + 7 * 3) * (1 + 2) = 210`.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   `cost.length == nums.length`
+*   `1 <= nums[i], cost[i] <= 1000`
+*   `1 <= k <= 1000`