关于各种子数组的和sum小于或者等于k这一类问题的总结

这种类型的情况可以分为两大类

1、当数组中全是正数的时候 用双指针算法
2、当数组中包括负数的时候用 前缀和 单调队列**

如果在使用前缀和求解的过程中 时间复杂度超时的情况

优化的方法主要有1、hash表 2、单调队列

209. Minimum Size Subarray Sum
Given an array of n positive integers and a positive integer s, find the minimal length of a contiguous subarray of which the sum ≥ s. If there isn’t one, return 0 instead.

Input: s = 7, nums = [2,3,1,2,4,3]
Output: 2
Explanation: the subarray [4,3] has the minimal length under the problem constraint.
思路 数组里全是正整数 使用双指针算法找到最小长度 因为都是整数可以让sum一直是单调递增
指针，移动指针可以指定什么时候该从队头弹出什么时候从队尾弹出类似单调队列的思想

class Solution {
public:
    int minSubArrayLen(int s, vector& nums) {
      if(nums.size()==0) return 0;
      int n=nums.size();
      int len=1e10;
      int sum=0;
      for(int i=0,j=0;j=s)
          {
             while((sum-nums[i])>=s) 
             {
                 sum-=nums[i];
                 i++;
             }
             len=min(len,j-i+1);
          } 
      }
      if(sum

53. Maximum Subarra
Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.
Example:

Input: [-2,1,-3,4,-1,2,1,-5,4],
Output: 6
Explanation: [4,-1,2,1] has the largest sum = 6.
思路：枚举每一位以i结尾的字数组如果前面的和小于当前数字就那么就结算当前数字作为最大字数组

class Solution {
public:
    int maxSubArray(vector& nums) {
        if(nums.size()==0) return 0;
        int n=nums.size();
        vector dp(n,0);
        dp[0]=nums[0];
        int maxval=nums[0];
        for(int i=1;idp[i]) dp[i]=nums[i];
            maxval=max(maxval,dp[i]);
        }
        return maxval;
        
    }
};

这里总结一下最大字段和的问题
1、当求一个子段和最大“没有长度不小于L的限制”的时候
思路 扫描该数组一直不断的加入子段当字段为负数的时候就结算，把当前字段清空，扫描过程中求的最大字段和就是所求的结果
2、当求一个子段和最大有“长度不小于L的限制”的时候
使用前缀和公式

$max\left\{aj..ai\right\}=max\left\{sumi-min\left\{sumj\right\}\right\}$
代码模板

double minval=0;
    /*for(int j=F;j<=N;j++)
    {
        for(int i=1;i<=j-F+1;i++)
        {
           minval=min(minval,sum[i-1]);
        }
        if(sum[j]-minval>0)
          return true;
    }*
    ///优化后的代码
    因为随着j的每次增加1个数i也每次只增加一个
    所以我们没有必要枚举i从0~i的之间最小值的情况只需要用一个变量记录当前的最小值每次与新的取值进行min操作就行
    for(int j=F,i=0;j<=N;j++,i++)
    {
        minval=min(minval,sum[i]);
        if((sum[j]-minval)>0) return true;
    }
    return false;

hash表类型

这种类型主要是求出现等于k的次数
560. Subarray Sum Equals K
Given an array of integers and an integer k, you need to find the total number of continuous subarrays whose sum equals to k.

Example 1:
Input:nums = [1,1,1], k = 2
Output: 2
第一种解法 前缀和
时间复杂度过高

class Solution {
public:
   
    int subarraySum(vector& nums, int k) {
        if(nums.size()==0) return 0;
        int n=nums.size();
        vector sum(n+1,0);
        for(int i=1;i<=n;i++)
        {
            sum[i]=sum[i-1]+nums[i-1];
        }
        //unordered_map hash;
        int count=0;
        for(int j=1;j<=n;j++)
        {
            for(int i=1;i<=j;i++)
            {
                if(sum[j]-sum[i-1]==k) count++;
            }
        }
        return count;
    }
};

第二种解法
思路：开一个hash表记录sum-k的次数

  class Solution {
public:
    int subarraySum(vector& nums, int k) {
        if(nums.size()==0) return 0;
        int n=nums.size();
        unordered_map hash;
        int sum=0;
        int res=0;
        for(int i=0;i0)
            {
                res+=hash[num];
            }
            hash[sum]++;
            
        }
        return res;
    }
};

单调队列类型

这种类型最难想到
862. Shortest Subarray with Sum at Least K
Return the length of the shortest, non-empty, contiguous subarray of A with sum at least K.

If there is no non-empty subarray with sum at least K, return -1.

Example 1:

Input: A = [1], K = 1
Output: 1
Example 2:

Input: A = [1,2], K = 4
Output: -1
Example 3:

Input: A = [2,-1,2], K = 3
Output: 3

第一种解法 前缀和（时间超时）

class Solution {
public:
    int shortestSubarray(vector& nums, int k) {
        if(nums.size()==0) return 0;
        int n=nums.size();
        vector sum(n+1,0);
        for(int i=1;i<=n;i++)
        {
            sum[i]=sum[i-1]+nums[i-1];
        }
        //unordered_map hash;
        int len=INT_MAX;
        for(int j=1;j<=n;j++)
        {
            for(int i=1;i<=j;i++)
            {
                if(sum[j]-sum[i-1]>=k) len=min(len,j-i+1);
            }
        }
        return len==INT_MAX?-1:len;
    }
};

第二种解法单调队列

 class Solution {
        public:
            int shortestSubarray(vector& nums, int k) {
                if(nums.size()==0) return 0;
                //if(nums.size()==1&&nums[0]==k) return 1;
                int n=nums.size();
                vector sum(n+1,0);
                for(int i=1;i<=n;i++)
                {
                    sum[i]=sum[i-1]+nums[i-1];
                }
                deque q;
                int len=INT_MAX;
                q.push_back(0);//注意这里和滑动窗口里存的下标不一样 这里时前缀和的下标
                for(int i=1;i<=n;i++)
                {
                     while(q.size()&&(sum[i]-sum[q.front()]>=k))
                     {
                         len=min(len,i-q.front());
                         q.pop_front();
                     }
                    while(q.size()&&sum[i]