Improved tasks 194, 1022, 2366, 3473

Author: javadev

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

@@ -1,45 +1,26 @@
 package g3401_3500.s3473_sum_of_k_subarrays_with_length_at_least_m
 
 // #Medium #Array #Dynamic_Programming #Prefix_Sum
-// #2025_03_06_Time_227_ms_(24.47%)_Space_99.61_MB_(48.94%)
-
-import kotlin.math.max
+// #2025_05_03_Time_33_ms_(98.18%)_Space_81.75_MB_(87.27%)
 
 class Solution {
     fun maxSum(nums: IntArray, k: Int, m: Int): Int {
         val n = nums.size
-        // Calculate prefix sums
-        val prefixSum = IntArray(n + 1)
-        for (i in 0..<n) {
-            prefixSum[i + 1] = prefixSum[i] + nums[i]
+        val dp = Array(k + 1) { IntArray(n + 1) { Int.MIN_VALUE } }
+        val ps = IntArray(n + 1)
+        for (i in nums.indices) {
+            ps[i + 1] = ps[i] + nums[i]
         }
-        // using elements from nums[0...i-1]
-        val dp = Array<IntArray>(n + 1) { IntArray(k + 1) }
-        // Initialize dp array
-        for (j in 1..k) {
-            for (i in 0..n) {
-                dp[i][j] = Int.Companion.MIN_VALUE / 2
-            }
+        for (j in 0..n) {
+            dp[0][j] = 0
         }
-        // Fill dp array
-        for (j in 1..k) {
-            val maxPrev = IntArray(n + 1)
-            for (i in 0..<n + 1) {
-                maxPrev[i] =
-                    if (i == 0) {
-                        dp[0][j - 1] - prefixSum[0]
-                    } else {
-                        max(maxPrev[i - 1], dp[i][j - 1] - prefixSum[i])
-                    }
-            }
-            for (i in m..n) {
-                // Option 1: Don't include the current element in any new subarray
-                dp[i][j] = dp[i - 1][j]
-                // Option 2: Form a new subarray ending at position i
-                // Find the best starting position for the subarray
-                dp[i][j] = max(dp[i][j], prefixSum[i] + maxPrev[i - m])
+        for (i in 1..k) {
+            var best = Int.MIN_VALUE
+            for (j in (i * m)..n) {
+                best = maxOf(best, dp[i - 1][j - m] - ps[j - m])
+                dp[i][j] = maxOf(dp[i][j - 1], ps[j] + best)
             }
         }
-        return dp[n][k]
+        return dp[k][n]
     }
 }