From b0213f3bae4f7845e4f0f0b731e19a5041fbf54a Mon Sep 17 00:00:00 2001 From: yanglbme Date: Sun, 19 Nov 2023 09:30:52 +0800 Subject: [PATCH] feat: add solutions to lc problem: No.0689 No.0689.Maximum Sum of 3 Non-Overlapping Subarrays --- .../README.md | 232 +++++++++++++++++ .../README_EN.md | 234 ++++++++++++++++++ .../Solution.cpp | 63 +++-- .../Solution.go | 64 +++-- .../Solution.java | 58 +++-- .../Solution.py | 43 ++-- .../Solution.ts | 48 ++++ 7 files changed, 645 insertions(+), 97 deletions(-) create mode 100644 solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/Solution.ts diff --git a/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/README.md b/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/README.md index 34cfcf9a94e26..5037dd53039bd 100644 --- a/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/README.md +++ b/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/README.md @@ -42,8 +42,22 @@ +**方法一：滑动窗口** + 滑动窗口，枚举第三个子数组的位置，同时维护前两个无重叠子数组的最大和及其位置。 +时间复杂度 $O(n)$，其中 $n$ 是数组 $nums$ 的长度。空间复杂度 $O(1)$。 + +**方法二：预处理前后缀 + 枚举中间子数组** + +我们可以预处理得到数组 $nums$ 的前缀和数组 $s$，其中 $s[i] = \sum_{j=0}^{i-1} nums[j]$，那么对于任意的 $i$，$j$，$s[j] - s[i]$ 就是子数组 $[i, j)$ 的和。 + +接下来，我们使用动态规划的方法，维护两个长度为 $n$ 的数组 $pre$ 和 $suf$，其中 $pre[i]$ 表示 $[0, i]$ 范围内长度为 $k$ 的子数组的最大和及其起始位置，$suf[i]$ 表示 $[i, n)$ 范围内长度为 $k$ 的子数组的最大和及其起始位置。 + +然后，我们枚举中间子数组的起始位置 $i$，那么三个子数组的和就是 $pre[i-1][0] + suf[i+k][0] + (s[i+k] - s[i])$，其中 $pre[i-1][0]$ 表示 $[0, i-1]$ 范围内长度为 $k$ 的子数组的最大和，$suf[i+k][0]$ 表示 $[i+k, n)$ 范围内长度为 $k$ 的子数组的最大和，$(s[i+k] - s[i])$ 表示 $[i, i+k)$ 范围内长度为 $k$ 的子数组的和。我们找出和的最大值对应的三个子数组的起始位置即可。 + +时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是数组 $nums$ 的长度。 + ### **Python3** @@ -77,6 +91,36 @@ class Solution: return ans ``` +```python +class Solution: + def maxSumOfThreeSubarrays(self, nums: List[int], k: int) -> List[int]: + n = len(nums) + s = list(accumulate(nums, initial=0)) + pre = [[] for _ in range(n)] + suf = [[] for _ in range(n)] + t = idx = 0 + for i in range(n - k + 1): + if (cur := s[i + k] - s[i]) > t: + pre[i + k - 1] = [cur, i] + t, idx = pre[i + k - 1] + else: + pre[i + k - 1] = [t, idx] + t = idx = 0 + for i in range(n - k, -1, -1): + if (cur := s[i + k] - s[i]) >= t: + suf[i] = [cur, i] + t, idx = suf[i] + else: + suf[i] = [t, idx] + t = 0 + ans = [] + for i in range(k, n - 2 * k + 1): + if (cur := s[i + k] - s[i] + pre[i - 1][0] + suf[i + k][0]) > t: + ans = [pre[i - 1][1], i, suf[i + k][1]] + t = cur + return ans +``` + ### **Java** @@ -116,6 +160,49 @@ class Solution { } ``` +```java +class Solution { + public int[] maxSumOfThreeSubarrays(int[] nums, int k) { + int n = nums.length; + int[] s = new int[n + 1]; + for (int i = 0; i < n; ++i) { + s[i + 1] = s[i] + nums[i]; + } + int[][] pre = new int[n][0]; + int[][] suf = new int[n][0]; + for (int i = 0, t = 0, idx = 0; i < n - k + 1; ++i) { + int cur = s[i + k] - s[i]; + if (cur > t) { + pre[i + k - 1] = new int[] {cur, i}; + t = cur; + idx = i; + } else { + pre[i + k - 1] = new int[] {t, idx}; + } + } + for (int i = n - k, t = 0, idx = 0; i >= 0; --i) { + int cur = s[i + k] - s[i]; + if (cur >= t) { + suf[i] = new int[] {cur, i}; + t = cur; + idx = i; + } else { + suf[i] = new int[] {t, idx}; + } + } + int[] ans = new int[0]; + for (int i = k, t = 0; i < n - 2 * k + 1; ++i) { + int cur = s[i + k] - s[i] + pre[i - 1][0] + suf[i + k][0]; + if (cur > t) { + ans = new int[] {pre[i - 1][1], i, suf[i + k][1]}; + t = cur; + } + } + return ans; + } +} +``` + ### **C++** ```cpp @@ -154,6 +241,55 @@ public: }; ``` +```cpp +class Solution { +public: + vector maxSumOfThreeSubarrays(vector& nums, int k) { + int n = nums.size(); + vector s(n + 1, 0); + for (int i = 0; i < n; ++i) { + s[i + 1] = s[i] + nums[i]; + } + + vector> pre(n, vector(2, 0)); + vector> suf(n, vector(2, 0)); + + for (int i = 0, t = 0, idx = 0; i < n - k + 1; ++i) { + int cur = s[i + k] - s[i]; + if (cur > t) { + pre[i + k - 1] = {cur, i}; + t = cur; + idx = i; + } else { + pre[i + k - 1] = {t, idx}; + } + } + + for (int i = n - k, t = 0, idx = 0; i >= 0; --i) { + int cur = s[i + k] - s[i]; + if (cur >= t) { + suf[i] = {cur, i}; + t = cur; + idx = i; + } else { + suf[i] = {t, idx}; + } + } + + vector ans; + for (int i = k, t = 0; i < n - 2 * k + 1; ++i) { + int cur = s[i + k] - s[i] + pre[i - 1][0] + suf[i + k][0]; + if (cur > t) { + ans = {pre[i - 1][1], i, suf[i + k][1]}; + t = cur; + } + } + + return ans; + } +}; +``` + ### **Go** ```go @@ -189,6 +325,102 @@ func maxSumOfThreeSubarrays(nums []int, k int) []int { } ``` +```go +func maxSumOfThreeSubarrays(nums []int, k int) (ans []int) { + n := len(nums) + s := make([]int, n+1) + for i := 0; i < n; i++ { + s[i+1] = s[i] + nums[i] + } + + pre := make([][]int, n) + suf := make([][]int, n) + + for i, t, idx := 0, 0, 0; i < n-k+1; i++ { + cur := s[i+k] - s[i] + if cur > t { + pre[i+k-1] = []int{cur, i} + t, idx = cur, i + } else { + pre[i+k-1] = []int{t, idx} + } + } + + for i, t, idx := n-k, 0, 0; i >= 0; i-- { + cur := s[i+k] - s[i] + if cur >= t { + suf[i] = []int{cur, i} + t, idx = cur, i + } else { + suf[i] = []int{t, idx} + } + } + + for i, t := k, 0; i < n-2*k+1; i++ { + cur := s[i+k] - s[i] + pre[i-1][0] + suf[i+k][0] + if cur > t { + ans = []int{pre[i-1][1], i, suf[i+k][1]} + t = cur + } + } + + return +} +``` + +### **TypeScript** + +```ts +function maxSumOfThreeSubarrays(nums: number[], k: number): number[] { + const n: number = nums.length; + const s: number[] = Array(n + 1).fill(0); + + for (let i = 0; i < n; ++i) { + s[i + 1] = s[i] + nums[i]; + } + + const pre: number[][] = Array(n) + .fill([]) + .map(() => new Array(2).fill(0)); + const suf: number[][] = Array(n) + .fill([]) + .map(() => new Array(2).fill(0)); + + for (let i = 0, t = 0, idx = 0; i < n - k + 1; ++i) { + const cur: number = s[i + k] - s[i]; + if (cur > t) { + pre[i + k - 1] = [cur, i]; + t = cur; + idx = i; + } else { + pre[i + k - 1] = [t, idx]; + } + } + + for (let i = n - k, t = 0, idx = 0; i >= 0; --i) { + const cur: number = s[i + k] - s[i]; + if (cur >= t) { + suf[i] = [cur, i]; + t = cur; + idx = i; + } else { + suf[i] = [t, idx]; + } + } + + let ans: number[] = []; + for (let i = k, t = 0; i < n - 2 * k + 1; ++i) { + const cur: number = s[i + k] - s[i] + pre[i - 1][0] + suf[i + k][0]; + if (cur > t) { + ans = [pre[i - 1][1], i, suf[i + k][1]]; + t = cur; + } + } + + return ans; +} +``` + ### **...** ``` diff --git a/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/README_EN.md b/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/README_EN.md index a42679392ac51..96b60968443fc 100644 --- a/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/README_EN.md +++ b/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/README_EN.md @@ -36,6 +36,22 @@ We could have also taken [2, 1], but an answer of [1, 3, 5] would be lexicograph ## Solutions +**Solution 1: Sliding Window** + +We use a sliding window to enumerate the position of the third subarray, while maintaining the maximum sum and its position of the first two non-overlapping subarrays. + +The time complexity is $O(n)$, where $n$ is the length of the array $nums$. The space complexity is $O(1)$. + +**Solution 2: Preprocessing Prefix and Suffix + Enumerating Middle Subarray** + +We can preprocess to get the prefix sum array $s$ of the array $nums$, where $s[i] = \sum_{j=0}^{i-1} nums[j]$. Then for any $i$, $j$, $s[j] - s[i]$ is the sum of the subarray $[i, j)$. + +Next, we use dynamic programming to maintain two arrays $pre$ and $suf$ of length $n$, where $pre[i]$ represents the maximum sum and its starting position of the subarray of length $k$ within the range $[0, i]$, and $suf[i]$ represents the maximum sum and its starting position of the subarray of length $k$ within the range $[i, n)$. + +Then, we enumerate the starting position $i$ of the middle subarray. The sum of the three subarrays is $pre[i-1][0] + suf[i+k][0] + (s[i+k] - s[i])$, where $pre[i-1][0]$ represents the maximum sum of the subarray of length $k$ within the range $[0, i-1]$, $suf[i+k][0]$ represents the maximum sum of the subarray of length $k$ within the range $[i+k, n)$, and $(s[i+k] - s[i])$ represents the sum of the subarray of length $k$ within the range $[i, i+k)$. We find the starting positions of the three subarrays corresponding to the maximum sum. + +The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the array $nums$. + ### **Python3** @@ -67,6 +83,36 @@ class Solution: return ans ``` +```python +class Solution: + def maxSumOfThreeSubarrays(self, nums: List[int], k: int) -> List[int]: + n = len(nums) + s = list(accumulate(nums, initial=0)) + pre = [[] for _ in range(n)] + suf = [[] for _ in range(n)] + t = idx = 0 + for i in range(n - k + 1): + if (cur := s[i + k] - s[i]) > t: + pre[i + k - 1] = [cur, i] + t, idx = pre[i + k - 1] + else: + pre[i + k - 1] = [t, idx] + t = idx = 0 + for i in range(n - k, -1, -1): + if (cur := s[i + k] - s[i]) >= t: + suf[i] = [cur, i] + t, idx = suf[i] + else: + suf[i] = [t, idx] + t = 0 + ans = [] + for i in range(k, n - 2 * k + 1): + if (cur := s[i + k] - s[i] + pre[i - 1][0] + suf[i + k][0]) > t: + ans = [pre[i - 1][1], i, suf[i + k][1]] + t = cur + return ans +``` + ### **Java** ```java @@ -104,6 +150,49 @@ class Solution { } ``` +```java +class Solution { + public int[] maxSumOfThreeSubarrays(int[] nums, int k) { + int n = nums.length; + int[] s = new int[n + 1]; + for (int i = 0; i < n; ++i) { + s[i + 1] = s[i] + nums[i]; + } + int[][] pre = new int[n][0]; + int[][] suf = new int[n][0]; + for (int i = 0, t = 0, idx = 0; i < n - k + 1; ++i) { + int cur = s[i + k] - s[i]; + if (cur > t) { + pre[i + k - 1] = new int[] {cur, i}; + t = cur; + idx = i; + } else { + pre[i + k - 1] = new int[] {t, idx}; + } + } + for (int i = n - k, t = 0, idx = 0; i >= 0; --i) { + int cur = s[i + k] - s[i]; + if (cur >= t) { + suf[i] = new int[] {cur, i}; + t = cur; + idx = i; + } else { + suf[i] = new int[] {t, idx}; + } + } + int[] ans = new int[0]; + for (int i = k, t = 0; i < n - 2 * k + 1; ++i) { + int cur = s[i + k] - s[i] + pre[i - 1][0] + suf[i + k][0]; + if (cur > t) { + ans = new int[] {pre[i - 1][1], i, suf[i + k][1]}; + t = cur; + } + } + return ans; + } +} +``` + ### **C++** ```cpp @@ -142,6 +231,55 @@ public: }; ``` +```cpp +class Solution { +public: + vector maxSumOfThreeSubarrays(vector& nums, int k) { + int n = nums.size(); + vector s(n + 1, 0); + for (int i = 0; i < n; ++i) { + s[i + 1] = s[i] + nums[i]; + } + + vector> pre(n, vector(2, 0)); + vector> suf(n, vector(2, 0)); + + for (int i = 0, t = 0, idx = 0; i < n - k + 1; ++i) { + int cur = s[i + k] - s[i]; + if (cur > t) { + pre[i + k - 1] = {cur, i}; + t = cur; + idx = i; + } else { + pre[i + k - 1] = {t, idx}; + } + } + + for (int i = n - k, t = 0, idx = 0; i >= 0; --i) { + int cur = s[i + k] - s[i]; + if (cur >= t) { + suf[i] = {cur, i}; + t = cur; + idx = i; + } else { + suf[i] = {t, idx}; + } + } + + vector ans; + for (int i = k, t = 0; i < n - 2 * k + 1; ++i) { + int cur = s[i + k] - s[i] + pre[i - 1][0] + suf[i + k][0]; + if (cur > t) { + ans = {pre[i - 1][1], i, suf[i + k][1]}; + t = cur; + } + } + + return ans; + } +}; +``` + ### **Go** ```go @@ -177,6 +315,102 @@ func maxSumOfThreeSubarrays(nums []int, k int) []int { } ``` +```go +func maxSumOfThreeSubarrays(nums []int, k int) (ans []int) { + n := len(nums) + s := make([]int, n+1) + for i := 0; i < n; i++ { + s[i+1] = s[i] + nums[i] + } + + pre := make([][]int, n) + suf := make([][]int, n) + + for i, t, idx := 0, 0, 0; i < n-k+1; i++ { + cur := s[i+k] - s[i] + if cur > t { + pre[i+k-1] = []int{cur, i} + t, idx = cur, i + } else { + pre[i+k-1] = []int{t, idx} + } + } + + for i, t, idx := n-k, 0, 0; i >= 0; i-- { + cur := s[i+k] - s[i] + if cur >= t { + suf[i] = []int{cur, i} + t, idx = cur, i + } else { + suf[i] = []int{t, idx} + } + } + + for i, t := k, 0; i < n-2*k+1; i++ { + cur := s[i+k] - s[i] + pre[i-1][0] + suf[i+k][0] + if cur > t { + ans = []int{pre[i-1][1], i, suf[i+k][1]} + t = cur + } + } + + return +} +``` + +### **TypeScript** + +```ts +function maxSumOfThreeSubarrays(nums: number[], k: number): number[] { + const n: number = nums.length; + const s: number[] = Array(n + 1).fill(0); + + for (let i = 0; i < n; ++i) { + s[i + 1] = s[i] + nums[i]; + } + + const pre: number[][] = Array(n) + .fill([]) + .map(() => new Array(2).fill(0)); + const suf: number[][] = Array(n) + .fill([]) + .map(() => new Array(2).fill(0)); + + for (let i = 0, t = 0, idx = 0; i < n - k + 1; ++i) { + const cur: number = s[i + k] - s[i]; + if (cur > t) { + pre[i + k - 1] = [cur, i]; + t = cur; + idx = i; + } else { + pre[i + k - 1] = [t, idx]; + } + } + + for (let i = n - k, t = 0, idx = 0; i >= 0; --i) { + const cur: number = s[i + k] - s[i]; + if (cur >= t) { + suf[i] = [cur, i]; + t = cur; + idx = i; + } else { + suf[i] = [t, idx]; + } + } + + let ans: number[] = []; + for (let i = k, t = 0; i < n - 2 * k + 1; ++i) { + const cur: number = s[i + k] - s[i] + pre[i - 1][0] + suf[i + k][0]; + if (cur > t) { + ans = [pre[i - 1][1], i, suf[i + k][1]]; + t = cur; + } + } + + return ans; +} +``` + ### **...** ``` diff --git a/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/Solution.cpp b/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/Solution.cpp index a0596d0b2084d..8baeba40d1770 100644 --- a/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/Solution.cpp +++ b/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/Solution.cpp @@ -1,33 +1,46 @@ class Solution { public: vector maxSumOfThreeSubarrays(vector& nums, int k) { - vector ans(3); - int s = 0, s1 = 0, s2 = 0, s3 = 0; - int mx1 = 0, mx12 = 0; - int idx1 = 0, idx121 = 0, idx122 = 0; - for (int i = k * 2; i < nums.size(); ++i) { - s1 += nums[i - k * 2]; - s2 += nums[i - k]; - s3 += nums[i]; - if (i >= k * 3 - 1) { - if (s1 > mx1) { - mx1 = s1; - idx1 = i - k * 3 + 1; - } - if (mx1 + s2 > mx12) { - mx12 = mx1 + s2; - idx121 = idx1; - idx122 = i - k * 2 + 1; - } - if (mx12 + s3 > s) { - s = mx12 + s3; - ans = {idx121, idx122, i - k + 1}; - } - s1 -= nums[i - k * 3 + 1]; - s2 -= nums[i - k * 2 + 1]; - s3 -= nums[i - k + 1]; + int n = nums.size(); + vector s(n + 1, 0); + for (int i = 0; i < n; ++i) { + s[i + 1] = s[i] + nums[i]; + } + + vector> pre(n, vector(2, 0)); + vector> suf(n, vector(2, 0)); + + for (int i = 0, t = 0, idx = 0; i < n - k + 1; ++i) { + int cur = s[i + k] - s[i]; + if (cur > t) { + pre[i + k - 1] = {cur, i}; + t = cur; + idx = i; + } else { + pre[i + k - 1] = {t, idx}; + } + } + + for (int i = n - k, t = 0, idx = 0; i >= 0; --i) { + int cur = s[i + k] - s[i]; + if (cur >= t) { + suf[i] = {cur, i}; + t = cur; + idx = i; + } else { + suf[i] = {t, idx}; + } + } + + vector ans; + for (int i = k, t = 0; i < n - 2 * k + 1; ++i) { + int cur = s[i + k] - s[i] + pre[i - 1][0] + suf[i + k][0]; + if (cur > t) { + ans = {pre[i - 1][1], i, suf[i + k][1]}; + t = cur; } } + return ans; } }; \ No newline at end of file diff --git a/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/Solution.go b/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/Solution.go index 35ba3d2e5a2f2..f42deecc50470 100644 --- a/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/Solution.go +++ b/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/Solution.go @@ -1,30 +1,40 @@ -func maxSumOfThreeSubarrays(nums []int, k int) []int { - ans := make([]int, 3) - s, s1, s2, s3 := 0, 0, 0, 0 - mx1, mx12 := 0, 0 - idx1, idx121, idx122 := 0, 0, 0 - for i := k * 2; i < len(nums); i++ { - s1 += nums[i-k*2] - s2 += nums[i-k] - s3 += nums[i] - if i >= k*3-1 { - if s1 > mx1 { - mx1 = s1 - idx1 = i - k*3 + 1 - } - if mx1+s2 > mx12 { - mx12 = mx1 + s2 - idx121 = idx1 - idx122 = i - k*2 + 1 - } - if mx12+s3 > s { - s = mx12 + s3 - ans = []int{idx121, idx122, i - k + 1} - } - s1 -= nums[i-k*3+1] - s2 -= nums[i-k*2+1] - s3 -= nums[i-k+1] +func maxSumOfThreeSubarrays(nums []int, k int) (ans []int) { + n := len(nums) + s := make([]int, n+1) + for i := 0; i < n; i++ { + s[i+1] = s[i] + nums[i] + } + + pre := make([][]int, n) + suf := make([][]int, n) + + for i, t, idx := 0, 0, 0; i < n-k+1; i++ { + cur := s[i+k] - s[i] + if cur > t { + pre[i+k-1] = []int{cur, i} + t, idx = cur, i + } else { + pre[i+k-1] = []int{t, idx} + } + } + + for i, t, idx := n-k, 0, 0; i >= 0; i-- { + cur := s[i+k] - s[i] + if cur >= t { + suf[i] = []int{cur, i} + t, idx = cur, i + } else { + suf[i] = []int{t, idx} + } + } + + for i, t := k, 0; i < n-2*k+1; i++ { + cur := s[i+k] - s[i] + pre[i-1][0] + suf[i+k][0] + if cur > t { + ans = []int{pre[i-1][1], i, suf[i+k][1]} + t = cur } } - return ans + + return } \ No newline at end of file diff --git a/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/Solution.java b/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/Solution.java index 2b02ca6b35c3c..9143c7df011fe 100644 --- a/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/Solution.java +++ b/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/Solution.java @@ -1,30 +1,38 @@ class Solution { public int[] maxSumOfThreeSubarrays(int[] nums, int k) { - int[] ans = new int[3]; - int s = 0, s1 = 0, s2 = 0, s3 = 0; - int mx1 = 0, mx12 = 0; - int idx1 = 0, idx121 = 0, idx122 = 0; - for (int i = k * 2; i < nums.length; ++i) { - s1 += nums[i - k * 2]; - s2 += nums[i - k]; - s3 += nums[i]; - if (i >= k * 3 - 1) { - if (s1 > mx1) { - mx1 = s1; - idx1 = i - k * 3 + 1; - } - if (mx1 + s2 > mx12) { - mx12 = mx1 + s2; - idx121 = idx1; - idx122 = i - k * 2 + 1; - } - if (mx12 + s3 > s) { - s = mx12 + s3; - ans = new int[] {idx121, idx122, i - k + 1}; - } - s1 -= nums[i - k * 3 + 1]; - s2 -= nums[i - k * 2 + 1]; - s3 -= nums[i - k + 1]; + int n = nums.length; + int[] s = new int[n + 1]; + for (int i = 0; i < n; ++i) { + s[i + 1] = s[i] + nums[i]; + } + int[][] pre = new int[n][0]; + int[][] suf = new int[n][0]; + for (int i = 0, t = 0, idx = 0; i < n - k + 1; ++i) { + int cur = s[i + k] - s[i]; + if (cur > t) { + pre[i + k - 1] = new int[] {cur, i}; + t = cur; + idx = i; + } else { + pre[i + k - 1] = new int[] {t, idx}; + } + } + for (int i = n - k, t = 0, idx = 0; i >= 0; --i) { + int cur = s[i + k] - s[i]; + if (cur >= t) { + suf[i] = new int[] {cur, i}; + t = cur; + idx = i; + } else { + suf[i] = new int[] {t, idx}; + } + } + int[] ans = new int[0]; + for (int i = k, t = 0; i < n - 2 * k + 1; ++i) { + int cur = s[i + k] - s[i] + pre[i - 1][0] + suf[i + k][0]; + if (cur > t) { + ans = new int[] {pre[i - 1][1], i, suf[i + k][1]}; + t = cur; } } return ans; diff --git a/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/Solution.py b/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/Solution.py index be0a31f731688..fa1bd07acbdd9 100644 --- a/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/Solution.py +++ b/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/Solution.py @@ -1,24 +1,27 @@ class Solution: def maxSumOfThreeSubarrays(self, nums: List[int], k: int) -> List[int]: - s = s1 = s2 = s3 = 0 - mx1 = mx12 = 0 - idx1, idx12 = 0, () + n = len(nums) + s = list(accumulate(nums, initial=0)) + pre = [[] for _ in range(n)] + suf = [[] for _ in range(n)] + t = idx = 0 + for i in range(n - k + 1): + if (cur := s[i + k] - s[i]) > t: + pre[i + k - 1] = [cur, i] + t, idx = pre[i + k - 1] + else: + pre[i + k - 1] = [t, idx] + t = idx = 0 + for i in range(n - k, -1, -1): + if (cur := s[i + k] - s[i]) >= t: + suf[i] = [cur, i] + t, idx = suf[i] + else: + suf[i] = [t, idx] + t = 0 ans = [] - for i in range(k * 2, len(nums)): - s1 += nums[i - k * 2] - s2 += nums[i - k] - s3 += nums[i] - if i >= k * 3 - 1: - if s1 > mx1: - mx1 = s1 - idx1 = i - k * 3 + 1 - if mx1 + s2 > mx12: - mx12 = mx1 + s2 - idx12 = (idx1, i - k * 2 + 1) - if mx12 + s3 > s: - s = mx12 + s3 - ans = [*idx12, i - k + 1] - s1 -= nums[i - k * 3 + 1] - s2 -= nums[i - k * 2 + 1] - s3 -= nums[i - k + 1] + for i in range(k, n - 2 * k + 1): + if (cur := s[i + k] - s[i] + pre[i - 1][0] + suf[i + k][0]) > t: + ans = [pre[i - 1][1], i, suf[i + k][1]] + t = cur return ans diff --git a/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/Solution.ts b/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/Solution.ts new file mode 100644 index 0000000000000..0bb3368c1774c --- /dev/null +++ b/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/Solution.ts @@ -0,0 +1,48 @@ +function maxSumOfThreeSubarrays(nums: number[], k: number): number[] { + const n: number = nums.length; + const s: number[] = Array(n + 1).fill(0); + + for (let i = 0; i < n; ++i) { + s[i + 1] = s[i] + nums[i]; + } + + const pre: number[][] = Array(n) + .fill([]) + .map(() => new Array(2).fill(0)); + const suf: number[][] = Array(n) + .fill([]) + .map(() => new Array(2).fill(0)); + + for (let i = 0, t = 0, idx = 0; i < n - k + 1; ++i) { + const cur: number = s[i + k] - s[i]; + if (cur > t) { + pre[i + k - 1] = [cur, i]; + t = cur; + idx = i; + } else { + pre[i + k - 1] = [t, idx]; + } + } + + for (let i = n - k, t = 0, idx = 0; i >= 0; --i) { + const cur: number = s[i + k] - s[i]; + if (cur >= t) { + suf[i] = [cur, i]; + t = cur; + idx = i; + } else { + suf[i] = [t, idx]; + } + } + + let ans: number[] = []; + for (let i = k, t = 0; i < n - 2 * k + 1; ++i) { + const cur: number = s[i + k] - s[i] + pre[i - 1][0] + suf[i + k][0]; + if (cur > t) { + ans = [pre[i - 1][1], i, suf[i + k][1]]; + t = cur; + } + } + + return ans; +}