题目：

给你一个长度为 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] 。

思路：这就是典型的前缀和问题

【1】首先我第一次就用的双层for循环+前缀和去解决

 代码如下：

class Solution {
public:
    long long maximumSubarraySum(vector<int>& nums, int k) {
        int n=nums.size();
        int MOD=1e9+7;
        long long int i,j;
        long long int mx[n];
        long long int sum=0;
        for(i=0;i<n;i++){
            sum+=nums[i];
            mx[i]=sum;
        }
        long long int maxsum=-9223372036854775808;
        for(i=0;i<=n-2;i++){
            long long int midd;
            for(j=i+1;j<n;j++){
                if(abs(nums[j]-nums[i])==k)  {
                     midd=mx[j]-mx[i]+nums[i];
                     maxsum=max(maxsum,midd);
                }
            }
          
        }
        return (maxsum==-9223372036854775808)?0:maxsum;
    }
};

定义的maxsum的值原因是long long 的最小值就是他，所以才可以去比较

这个代码的思路就比较简单了，先定义一个等长的数组去存放前缀和，然后双层for循环，去找到区间i,j(满足两边界的数组值的绝对值为k),然后用前缀和mx[j]-mx[i]+nums[i]即可

这样是没问题的，应该是时间复杂度高了，O(N*N)

在leetcode就差几个样例

第二种 就得在前缀和之的基础上加入哈希表去做就可以，这样复杂度也就变成了O（n）

class Solution {
public:
    long long maximumSubarraySum(vector<int> &nums, int k) {
        long long ans = LLONG_MIN, sum = 0;
        unordered_map<int, long long> min_s;
        for (int x: nums) {
            auto it = min_s.find(x + k);
            if (it != min_s.end()) {
                ans = max(ans, sum + x - it->second);
            }

            it = min_s.find(x - k);
            if (it != min_s.end()) {
                ans = max(ans, sum + x - it->second);
            }

            it = min_s.find(x);
            if (it == min_s.end() || sum < it->second) {
                min_s[x] = sum;
            }

            sum += x;
        }
        return ans == LLONG_MIN ? 0 : ans;
    }
};