除自身以外数组的乘积 + 和为K的子数组⭐ + 长度最小的子数组

238. 除自身以外数组的乘积

这道题很简单,正向算一次乘法，反向再算一次

class Solution {
public:
    vector productExceptSelf(vector& nums) {
        int n = nums.size();
        if( n <=1) return {};  
        vector res(n,1);
        res[0] = 1;
        for(int i = 1; i < n ; i++){
            res[i] = res[i-1] * nums[i-1]; 
        }
        int sum = 1;
        for(int i = n-1; i>=0; i--){
            res[i] = sum*res[i];
            sum *= nums[i];
        }
        return res;
        

    }
};

⭐ 560. 和为K的子数组

这个好难啊，前缀和至今也不是明白。

image.png

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

09. 长度最小的子数组

这道题也不会呀，需要掌握两种方法。滑动窗口 AND 前缀+二分
题解

方法一 滑动窗口

class Solution {
public:
    int minSubArrayLen(int target, vector& nums) {
      int n = nums.size();
      int i =0, j = 0;
      int sum = 0, res = INT_MAX;
      while(j < nums.size()){
          sum += nums[j];
          while(i < nums.size() && sum>=target){
              res = min(res,j-i+1);
              sum-=nums[i];
              i++;
          }
          j++;
      }
      return res == INT_MAX?0:res;
    }
};

方法二 前缀和二分

因为这道题保证了数组中每个元素都为正，所以前缀和一定是递增的，这一点保证了二分的正确性。如果题目没有说明数组中每个元素都为正，这里就不能使用二分来查找这个位置了。

class Solution {
public:
    int minSubArrayLen(int s, vector& nums) {
        int n = nums.size();
        if (n == 0) {
            return 0;
        }
        int ans = INT_MAX;
        vector sums(n + 1, 0); 
        // 为了方便计算，令 size = n + 1 
        // sums[0] = 0 意味着前 0 个元素的前缀和为 0
        // sums[1] = A[0] 前 1 个元素的前缀和为 A[0]
        // 以此类推
        for (int i = 1; i <= n; i++) {
            sums[i] = sums[i - 1] + nums[i - 1];
        }
        for (int i = 1; i <= n; i++) {
            int target = s + sums[i - 1];
            auto bound = lower_bound(sums.begin(), sums.end(), target);
            if (bound != sums.end()) {
                ans = min(ans, static_cast((bound - sums.begin()) - (i - 1)));//⭐
            }
        }
        return ans == INT_MAX ? 0 : ans;
    }
};

private int LowerBound(int[] a, int l, int r, int target) 
{
    int mid = -1, originL = l, originR = r;
    while (l < r) 
    {
        mid = (l + r) >> 1;
        if (a[mid] < target) l = mid + 1;
        else r = mid;
    } 

    return (a[l] >= target) ? l : -1;
}