Added tasks 3427-3430

Author: javadev

src/main/java/g3401_3500/s3427_sum_of_variable_length_subarrays/Solution.java

@@ -0,0 +1,15 @@
+package g3401_3500.s3427_sum_of_variable_length_subarrays;
+
+// #Easy #Array #Prefix_Sum #2025_01_22_Time_0_(100.00%)_Space_43.77_(58.41%)
+
+public class Solution {
+    public int subarraySum(int[] nums) {
+        int res = nums[0];
+        for (int i = 1; i < nums.length; i++) {
+            int j = i - nums[i] - 1;
+            nums[i] += nums[i - 1];
+            res += nums[i] - (j < 0 ? 0 : nums[j]);
+        }
+        return res;
+    }
+}

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

@@ -0,0 +1,94 @@
+3427\. Sum of Variable Length Subarrays
+
+Easy
+
+You are given an integer array `nums` of size `n`. For **each** index `i` where `0 <= i < n`, define a **non-empty subarrays** `nums[start ... i]` where `start = max(0, i - nums[i])`.
+
+Return the total sum of all elements from the subarray defined for each index in the array.
+
+**Example 1:**
+
+**Input:** nums = [2,3,1]
+
+**Output:** 11
+
+**Explanation:**
+
+i
+
+Subarray
+
+Sum
+
+0
+
+`nums[0] = [2]`
+
+2
+
+1
+
+`nums[0 ... 1] = [2, 3]`
+
+5
+
+2
+
+`nums[1 ... 2] = [3, 1]`
+
+4
+
+**Total Sum**
+
+11
+
+The total sum is 11. Hence, 11 is the output.
+
+**Example 2:**
+
+**Input:** nums = [3,1,1,2]
+
+**Output:** 13
+
+**Explanation:**
+
+i
+
+Subarray
+
+Sum
+
+0
+
+`nums[0] = [3]`
+
+3
+
+1
+
+`nums[0 ... 1] = [3, 1]`
+
+4
+
+2
+
+`nums[1 ... 2] = [1, 1]`
+
+2
+
+3
+
+`nums[1 ... 3] = [1, 1, 2]`
+
+4
+
+**Total Sum**
+
+13
+
+The total sum is 13. Hence, 13 is the output.
+
+**Constraints:**
+
+*   `1 <= n == nums.length <= 100`
+*   `1 <= nums[i] <= 1000`

src/main/java/g3401_3500/s3428_maximum_and_minimum_sums_of_at_most_size_k_subsequences/Solution.java

@@ -0,0 +1,62 @@
+package g3401_3500.s3428_maximum_and_minimum_sums_of_at_most_size_k_subsequences;
+
+// #Medium #Array #Dynamic_Programming #Math #Sorting #Combinatorics
+// #2025_01_22_Time_28_(99.74%)_Space_65.01_(35.71%)
+
+import java.util.Arrays;
+
+public class Solution {
+    private static final int MOD = (int) 1e9 + 7;
+    private static long[] fact, invFact;
+
+    public int minMaxSums(int[] nums, int k) {
+        int n = nums.length;
+        Arrays.sort(nums);
+        if (fact == null || fact.length < n + 1) {
+            buildFactorials(n);
+        }
+        long[] sum = new long[n + 1];
+        sum[0] = 1;
+        for (int i = 0; i < n; i++) {
+            long val = (2L * sum[i]) % MOD;
+            if (i + 1 >= k) {
+                val = (val - comb(i, k - 1) + MOD) % MOD;
+            }
+            sum[i + 1] = val;
+        }
+        long res = 0;
+        for (int i = 0; i < n; i++) {
+            long add = (sum[i] + sum[n - 1 - i]) % MOD;
+            res = (res + (nums[i] % MOD) * add) % MOD;
+        }
+        return (int) res;
+    }
+
+    private void buildFactorials(int n) {
+        fact = new long[n + 1];
+        invFact = new long[n + 1];
+        fact[0] = 1;
+        for (int i = 1; i <= n; i++) {
+            fact[i] = (fact[i - 1] * i) % MOD;
+        }
+        invFact[n] = pow(fact[n], MOD - 2);
+        for (int i = n - 1; i >= 0; i--) {
+            invFact[i] = (invFact[i + 1] * (i + 1)) % MOD;
+        }
+    }
+
+    private long comb(int n, int r) {
+        if (r < 0 || r > n) return 0;
+        return fact[n] * invFact[r] % MOD * invFact[n - r] % MOD;
+    }
+
+    private long pow(long base, int exp) {
+        long ans = 1L;
+        while (exp > 0) {
+            if ((exp & 1) == 1) ans = (ans * base) % MOD;
+            base = (base * base) % MOD;
+            exp >>= 1;
+        }
+        return ans;
+    }
+}

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

@@ -0,0 +1,109 @@
+3428\. Maximum and Minimum Sums of at Most Size K Subsequences
+
+Medium
+
+You are given an integer array `nums` and a positive integer `k`. Return the sum of the **maximum** and **minimum** elements of all
+
+**subsequences**
+
+of `nums` with **at most** `k` elements.
+
+Since the answer may be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3], k = 2
+
+**Output:** 24
+
+**Explanation:**
+
+The subsequences of `nums` with at most 2 elements are:
+
+**Subsequence**
+
+Minimum
+
+Maximum
+
+Sum
+
+`[1]`
+
+1
+
+1
+
+2
+
+`[2]`
+
+2
+
+2
+
+4
+
+`[3]`
+
+3
+
+3
+
+6
+
+`[1, 2]`
+
+1
+
+2
+
+3
+
+`[1, 3]`
+
+1
+
+3
+
+4
+
+`[2, 3]`
+
+2
+
+3
+
+5
+
+**Final Total**
+
+24
+
+The output would be 24.
+
+**Example 2:**
+
+**Input:** nums = [5,0,6], k = 1
+
+**Output:** 22
+
+**Explanation:**
+
+For subsequences with exactly 1 element, the minimum and maximum values are the element itself. Therefore, the total is `5 + 5 + 0 + 0 + 6 + 6 = 22`.
+
+**Example 3:**
+
+**Input:** nums = [1,1,1], k = 2
+
+**Output:** 12
+
+**Explanation:**
+
+The subsequences `[1, 1]` and `[1]` each appear 3 times. For all of them, the minimum and maximum are both 1. Thus, the total is 12.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>9</sup></code>
+*   `1 <= k <= min(70, nums.length)`

src/main/java/g3401_3500/s3429_paint_house_iv/Solution.java

@@ -0,0 +1,33 @@
+package g3401_3500.s3429_paint_house_iv;
+
+// #Medium #Array #Dynamic_Programming #2025_01_22_Time_5_(100.00%)_Space_106.29_(78.64%)
+
+public class Solution {
+    public long minCost(int n, int[][] cost) {
+        long dp0 = 0;
+        long dp1 = 0;
+        long dp2 = 0;
+        long dp3 = 0;
+        long dp4 = 0;
+        long dp5 = 0;
+        for (int i = 0; i < n / 2; ++i) {
+            long nextdp0 = Math.min(Math.min(dp2, dp3), dp4) + cost[i][0] + cost[n - i - 1][1];
+            long nextdp1 = Math.min(Math.min(dp2, dp4), dp5) + cost[i][0] + cost[n - i - 1][2];
+            long nextdp2 = Math.min(Math.min(dp0, dp1), dp5) + cost[i][1] + cost[n - i - 1][0];
+            long nextdp3 = Math.min(Math.min(dp0, dp4), dp5) + cost[i][1] + cost[n - i - 1][2];
+            long nextdp4 = Math.min(Math.min(dp0, dp1), dp3) + cost[i][2] + cost[n - i - 1][0];
+            long nextdp5 = Math.min(Math.min(dp1, dp2), dp3) + cost[i][2] + cost[n - i - 1][1];
+            dp0 = nextdp0;
+            dp1 = nextdp1;
+            dp2 = nextdp2;
+            dp3 = nextdp3;
+            dp4 = nextdp4;
+            dp5 = nextdp5;
+        }
+        long ans = Long.MAX_VALUE;
+        for (long x : new long[] {dp0, dp1, dp2, dp3, dp4, dp5}) {
+            ans = Math.min(ans, x);
+        }
+        return ans;
+    }
+}

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

@@ -0,0 +1,53 @@
+3429\. Paint House IV
+
+Medium
+
+You are given an **even** integer `n` representing the number of houses arranged in a straight line, and a 2D array `cost` of size `n x 3`, where `cost[i][j]` represents the cost of painting house `i` with color `j + 1`.
+
+The houses will look **beautiful** if they satisfy the following conditions:
+
+*   No **two** adjacent houses are painted the same color.
+*   Houses **equidistant** from the ends of the row are **not** painted the same color. For example, if `n = 6`, houses at positions `(0, 5)`, `(1, 4)`, and `(2, 3)` are considered equidistant.
+
+Return the **minimum** cost to paint the houses such that they look **beautiful**.
+
+**Example 1:**
+
+**Input:** n = 4, cost = [[3,5,7],[6,2,9],[4,8,1],[7,3,5]]
+
+**Output:** 9
+
+**Explanation:**
+
+The optimal painting sequence is `[1, 2, 3, 2]` with corresponding costs `[3, 2, 1, 3]`. This satisfies the following conditions:
+
+*   No adjacent houses have the same color.
+*   Houses at positions 0 and 3 (equidistant from the ends) are not painted the same color `(1 != 2)`.
+*   Houses at positions 1 and 2 (equidistant from the ends) are not painted the same color `(2 != 3)`.
+
+The minimum cost to paint the houses so that they look beautiful is `3 + 2 + 1 + 3 = 9`.
+
+**Example 2:**
+
+**Input:** n = 6, cost = [[2,4,6],[5,3,8],[7,1,9],[4,6,2],[3,5,7],[8,2,4]]
+
+**Output:** 18
+
+**Explanation:**
+
+The optimal painting sequence is `[1, 3, 2, 3, 1, 2]` with corresponding costs `[2, 8, 1, 2, 3, 2]`. This satisfies the following conditions:
+
+*   No adjacent houses have the same color.
+*   Houses at positions 0 and 5 (equidistant from the ends) are not painted the same color `(1 != 2)`.
+*   Houses at positions 1 and 4 (equidistant from the ends) are not painted the same color `(3 != 1)`.
+*   Houses at positions 2 and 3 (equidistant from the ends) are not painted the same color `(2 != 3)`.
+
+The minimum cost to paint the houses so that they look beautiful is `2 + 8 + 1 + 2 + 3 + 2 = 18`.
+
+**Constraints:**
+
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   `n` is even.
+*   `cost.length == n`
+*   `cost[i].length == 3`
+*   <code>0 <= cost[i]\[j] <= 10<sup>5</sup></code>