[LeetCode Sync] Runtime - 26 ms (67.12%), Memory - 20.5 MB (50.41%)

Author: NamVr

0689-maximum-sum-of-3-non-overlapping-subarrays/README.md

@@ -0,0 +1,29 @@
+<p>Given an integer array <code>nums</code> and an integer <code>k</code>, find three non-overlapping subarrays of length <code>k</code> with maximum sum and return them.</p>
+
+<p>Return the result as a list of indices representing the starting position of each interval (<strong>0-indexed</strong>). If there are multiple answers, return the lexicographically smallest one.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2,1,2,6,7,5,1], k = 2
+<strong>Output:</strong> [0,3,5]
+<strong>Explanation:</strong> Subarrays [1, 2], [2, 6], [7, 5] correspond to the starting indices [0, 3, 5].
+We could have also taken [2, 1], but an answer of [1, 3, 5] would be lexicographically larger.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2,1,2,1,2,1,2,1], k = 2
+<strong>Output:</strong> [0,2,4]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 2 * 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;&nbsp;2<sup>16</sup></code></li>
+	<li><code>1 &lt;= k &lt;= floor(nums.length / 3)</code></li>
+</ul>

0689-maximum-sum-of-3-non-overlapping-subarrays/solution.py

@@ -0,0 +1,52 @@
+class Solution:
+    def maxSumOfThreeSubarrays(self, nums: List[int], k: int) -> List[int]:
+        n = len(nums)
+        max_sum = 0
+
+        # Create prefix sum array using accumulate
+        prefix_sum = [0] + list(accumulate(nums))
+
+        # Initialize arrays for best indices
+        left_max_idx = [0] * n
+        right_max_idx = [0] * n
+        result = [0] * 3
+
+        # Calculate best left subarray positions
+        curr_max_sum = prefix_sum[k] - prefix_sum[0]
+        for i in range(k, n):
+            curr_sum = prefix_sum[i + 1] - prefix_sum[i + 1 - k]
+            if curr_sum > curr_max_sum:
+                left_max_idx[i] = i + 1 - k
+                curr_max_sum = curr_sum
+            else:
+                left_max_idx[i] = left_max_idx[i - 1]
+
+        # Calculate best right subarray positions
+        right_max_idx[n - k] = n - k
+        curr_max_sum = prefix_sum[n] - prefix_sum[n - k]
+        for i in range(n - k - 1, -1, -1):
+            curr_sum = prefix_sum[i + k] - prefix_sum[i]
+            if curr_sum >= curr_max_sum:
+                right_max_idx[i] = i
+                curr_max_sum = curr_sum
+            else:
+                right_max_idx[i] = right_max_idx[i + 1]
+
+        # Find optimal middle position
+        for i in range(k, n - 2 * k + 1):
+            left_idx = left_max_idx[i - 1]
+            right_idx = right_max_idx[i + k]
+            total_sum = (
+                prefix_sum[i + k]
+                - prefix_sum[i]
+                + prefix_sum[left_idx + k]
+                - prefix_sum[left_idx]
+                + prefix_sum[right_idx + k]
+                - prefix_sum[right_idx]
+            )
+
+            if total_sum > max_sum:
+                max_sum = total_sum
+                result = [left_idx, i, right_idx]
+
+        return result