Added tasks 3427-3430

Author: javadev

src/main/kotlin/g3401_3500/s3427_sum_of_variable_length_subarrays/Solution.kt

@@ -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%)
+
+class Solution {
+    fun subarraySum(nums: IntArray): Int {
+        var res = nums[0]
+        for (i in 1..<nums.size) {
+            val j = i - nums[i] - 1
+            nums[i] += nums[i - 1]
+            res += nums[i] - (if (j < 0) 0 else nums[j])
+        }
+        return res
+    }
+}

src/main/kotlin/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/kotlin/g3401_3500/s3428_maximum_and_minimum_sums_of_at_most_size_k_subsequences/Solution.kt

@@ -0,0 +1,72 @@
+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_167_(77.78%)_Space_75.34_(66.67%)
+
+class Solution {
+    private lateinit var fact: LongArray
+    private lateinit var inv: LongArray
+
+    private fun precomputeFactorials(n: Int) {
+        fact = LongArray(n + 1)
+        inv = LongArray(n + 1)
+        fact[0] = 1
+        for (i in 1..n) {
+            fact[i] = (fact[i - 1] * i) % MOD
+        }
+        inv[n] = power(fact[n], (MOD - 2).toLong(), MOD)
+        for (i in n - 1 downTo 0) {
+            inv[i] = (inv[i + 1] * (i + 1)) % MOD
+        }
+    }
+
+    private fun power(a: Long, b: Long, m: Int): Long {
+        var a = a
+        var b = b
+        var `val`: Long = 1
+        a = a % m
+        while (b > 0) {
+            if ((b and 1L) == 1L) `val` = (`val` * a) % m
+            b = b shr 1
+            a = (a * a) % m
+        }
+        return `val`
+    }
+
+    private fun nCr(n: Int, r: Int): Long {
+        if (r < 0 || r > n) return 0
+        return (fact[n] * inv[r] % MOD * inv[n - r]) % MOD
+    }
+
+    fun minMaxSums(nums: IntArray, k: Int): Int {
+        val n = nums.size
+        nums.sort()
+        precomputeFactorials(n)
+        var sum: Long = 0
+        for (i in 0..<n) {
+            var `val`: Long = 0
+            val a = i
+            val b = n - 1 - i
+            run {
+                var j = 0
+                while (j < k && j <= a) {
+                    `val` = (`val` + nCr(a, j)) % MOD
+                    j++
+                }
+            }
+            sum = (sum + (`val` * nums[i]) % MOD) % MOD
+            `val` = 0
+            var j = 0
+            while (j < k && j <= b) {
+                `val` = (`val` + nCr(b, j)) % MOD
+                j++
+            }
+            sum = (sum + (`val` * nums[i]) % MOD) % MOD
+        }
+        return sum.toInt()
+    }
+
+    companion object {
+        private const val MOD = 1e9.toInt() + 7
+    }
+}

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

@@ -0,0 +1,59 @@
+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/kotlin/g3401_3500/s3429_paint_house_iv/Solution.kt

@@ -0,0 +1,41 @@
+package g3401_3500.s3429_paint_house_iv
+
+// #Medium #Array #Dynamic_Programming #2025_01_22_Time_10_(100.00%)_Space_119.77_(84.62%)
+
+import kotlin.math.min
+
+class Solution {
+    fun minCost(n: Int, cost: Array<IntArray>): Long {
+        var dp0: Long = 0
+        var dp1: Long = 0
+        var dp2: Long = 0
+        var dp3: Long = 0
+        var dp4: Long = 0
+        var dp5: Long = 0
+        for (i in 0..<n / 2) {
+            val nextdp0: Long =
+                min(min(dp2, dp3), dp4) + cost[i][0] + cost[n - i - 1][1]
+            val nextdp1: Long =
+                min(min(dp2, dp4), dp5) + cost[i][0] + cost[n - i - 1][2]
+            val nextdp2: Long =
+                min(min(dp0, dp1), dp5) + cost[i][1] + cost[n - i - 1][0]
+            val nextdp3: Long =
+                min(min(dp0, dp4), dp5) + cost[i][1] + cost[n - i - 1][2]
+            val nextdp4: Long =
+                min(min(dp0, dp1), dp3) + cost[i][2] + cost[n - i - 1][0]
+            val nextdp5: Long =
+                min(min(dp1, dp2), dp3) + cost[i][2] + cost[n - i - 1][1]
+            dp0 = nextdp0
+            dp1 = nextdp1
+            dp2 = nextdp2
+            dp3 = nextdp3
+            dp4 = nextdp4
+            dp5 = nextdp5
+        }
+        var ans = Long.Companion.MAX_VALUE
+        for (x in longArrayOf(dp0, dp1, dp2, dp3, dp4, dp5)) {
+            ans = min(ans, x).toLong()
+        }
+        return ans
+    }
+}

src/main/kotlin/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>

src/main/kotlin/g3401_3500/s3430_maximum_and_minimum_sums_of_at_most_size_k_subarrays/Solution.kt

@@ -0,0 +1,47 @@
+package g3401_3500.s3430_maximum_and_minimum_sums_of_at_most_size_k_subarrays
+
+// #Hard #Array #Math #Stack #Monotonic_Stack #2025_01_22_Time_31_(100.00%)_Space_74.84_(24.24%)
+
+import kotlin.math.min
+
+class Solution {
+    fun minMaxSubarraySum(nums: IntArray, k: Int): Long {
+        val sum = solve(nums, k)
+        for (i in nums.indices) {
+            nums[i] = -nums[i]
+        }
+        return sum - solve(nums, k)
+    }
+
+    private fun solve(nums: IntArray, k: Int): Long {
+        val n = nums.size
+        val left = IntArray(n)
+        val right = IntArray(n)
+        val st = IntArray(n)
+        var top = -1
+        for (i in 0..<n) {
+            val num = nums[i]
+            while (top != -1 && num < nums[st[top]]) {
+                right[st[top--]] = i
+            }
+            left[i] = if (top == -1) -1 else st[top]
+            st[++top] = i
+        }
+        while (0 <= top) {
+            right[st[top--]] = n
+        }
+        var ans: Long = 0
+        for (i in 0..<n) {
+            val num = nums[i]
+            val l = min((i - left[i]), k)
+            val r = min((right[i] - i), k)
+            if (l + r - 1 <= k) {
+                ans += num.toLong() * l * r
+            } else {
+                val cnt = (k - r + 1).toLong() * r + (l + r - k - 1).toLong() * (r + k - l) / 2
+                ans += num * cnt
+            }
+        }
+        return ans
+    }
+}