LeetCode 3026. 最大好子数组和

3026. 最大好子数组和

给你一个长度为 n 的数组 nums 和一个 正 整数 k 。

如果 nums 的一个 子数组 中，第一个元素和最后一个元素 差的绝对值恰好 为 k ，我们称这个子数组为 好 的。换句话说，如果子数组 nums[i..j] 满足 |nums[i] - nums[j]| == k ，那么它是一个好子数组。

请你返回 nums 中 好 子数组的 最大 和，如果没有好子数组，返回 0 。

示例 1：

输入：nums = [1,2,3,4,5,6], k = 1
输出：11
解释：好子数组中第一个元素和最后一个元素的差的绝对值必须为 1 。好子数组有 [1,2] ，[2,3] ，[3,4] ，[4,5] 和 [5,6] 。最大子数组和为 11 ，对应的子数组为 [5,6] 。

示例 2：

输入：nums = [-1,3,2,4,5], k = 3
输出：11
解释：好子数组中第一个元素和最后一个元素的差的绝对值必须为 3 。好子数组有 [-1,3,2] 和 [2,4,5] 。最大子数组和为 11 ，对应的子数组为 [2,4,5] 。

示例 3：

输入：nums = [-1,-2,-3,-4], k = 2
输出：-6
解释：好子数组中第一个元素和最后一个元素的差的绝对值必须为 2 。好子数组有 [-1,-2,-3] 和 [-2,-3,-4] 。最大子数组和为 -6 ，对应的子数组为 [-1,-2,-3] 。

提示：

• 2 <= nums.length <= 10^5
• -10^9 <= nums[i] <= 10^9
• 1 <= k <= 10^9

---

提示 1

Save all the prefix sums into a HashMap.

---

提示 2

For the index i store the element at index i + 1 as the key and the prefix sum till i as the value.

---

提示 3

For each prefix sum ending at nums[i], try finding nums[i] - k and nums[i] + k in the HashMap and update the answer.

解法：前缀和

为方便描述，把 nums 简称为 a。

对于数组 a，定义它的前缀和 s[0]=0，s[i+1]=s[i]+a[i]。

例如 a=[1,2,1,2]，对应的前缀和数组为 s=[0,1,3,4,6]。

通过前缀和，我们可以把连续子数组的元素和转换成两个前缀和的差，a[left] 到 a[right] 的元素和等于 s[right+1]−s[left]
例如 a 的子数组 [2,1,2] 的和就可以用 s[4]−s[1]=6−1=5 算出来。

注：s[0]=0 表示一个空数组的元素和。为什么要额外定义它？想一想，如果要计算的子数组恰好是一个前缀（从 a[0] 到 a[right]），你要用 s[right+1] 减去谁呢？通过定义 s[0]=0，任意子数组（包括前缀）都可以表示为两个前缀和的差。

子数组 a[i..j] 的元素和为 s[j+1]−s[i]
枚举 j，我们需要找到最小的 s[i]，满足 ∣a[i]−a[j]∣=k，即 a[i]=a[j]−k 或 a[i]=a[j]+k。

定义哈希表 minS，键为 a[i]，值为相同 a[i] 下的 s[i] 的最小值。

子数组最后一个数为 a[j] 时，子数组的最大元素和为

s[j+1]−minS[a[i]]
s[j+1]−min(minS[a[j]−k],minS[a[j]+k])
​

Java版：

class Solution {
    public long maximumSubarraySum(int[] nums, int k) {
        long ans = Long.MIN_VALUE;
        long presum = 0;
        Map<Integer, Long> map = new HashMap<>();
        for (int num: nums) {
            // 取Long.MAX_VALUE会超出范围，所以取 Long.MAX_VALUE / 2
            long s1 = map.getOrDefault(num - k, Long.MAX_VALUE / 2);
            long s2 = map.getOrDefault(num + k, Long.MAX_VALUE / 2);
            ans = Math.max(ans, presum + num - Math.min(s1, s2));
            map.merge(num, presum, Math::min);
            presum += num;
        }
        // 如果没有符合要求的子数组，ans == -4611686018427387897 比 Long.MIN_VALUE / 2 略大一些
        // Long.MIN_VALUE / 2 == -4611686018427387904
        return ans > Long.MIN_VALUE / 3 ? ans : 0;
    }
}

Python3版：

class Solution:
    def maximumSubarraySum(self, nums: List[int], k: int) -> int:
        ans = -inf
        presum = 0
        mins = dict()
        for num in nums:
            s1 = mins[num - k] if num - k in mins else inf
            s2 = mins[num + k] if num + k in mins else inf 
            ans = max(ans, presum + num - min(s1, s2))
            mins[num] = min(mins[num], presum) if num in mins else presum
            presum += num  
        return ans if ans > -inf else 0 

复杂度分析

• 时间复杂度：O(n)，其中 n 为 nums 的长度。
• 空间复杂度：O(n)。