leetcode 子数组 相关问题(分析+代码)

560. 和为K的子数组

给定一个整数数组和一个整数 k，你需要找到该数组中和为 k 的连续的子数组的个数。

示例 1 :
输入:nums = [1,1,1], k = 2
输出: 2 , [1,1] 与 [1,1] 为两种不同的情况。

分析：找到该数组中和为k的连续的子数组，实际上就是找从 i 到 j 和为k的数组个数，因此，如果用sum表示从下标0到 i 的和，也就是找 sum[i]-sum[j]=k 的个数。故可以用一个数组存储sum，然后用MAP存储从该sum值到该值出现次数的映射关系，如果遍历sum[i]时，发现sum[i]-k已经出现过，则加上其值即可。

• 需要先判断是否存在，然后再对自身sum[i]建立映射，避免出现k=0的情况导致错误
• 需要注意的是，sum[0]=0,即未添加任何元素，或者在map初始化时添加map[0]=1

class Solution {
     
public:
    int subarraySum(vector<int>& nums, int k) 
    {
     
        vector<int> sum(nums.size()+1);
        sum[0]=0;
        for(int i=1;i<=nums.size();i++)
        {
     
            sum[i]=sum[i-1]+nums[i-1];   
        }
        int result=0;
        //  如果从j到i和为k,则 sum[i]-sum[j-1]=k
        unordered_map<int,int> MAP; //建立映射,从 sum[i]到其值出现的次数的映射
		for(int i=0;i<sum.size();i++)
		{
     
			if(MAP.find(sum[i]-k)!=MAP.end()) //判断差为k的是否已经出现
				result+=MAP[sum[i]-k];	
            MAP[sum[i]]++;
        } 
        return result;
    }
};

但是我们发现，其实sum并不需要用数组存储起来，可以在求和过程中直接建立映射并判断即可,代码可以变得更加简洁。

class Solution {
     
public:
    int subarraySum(vector<int>& nums, int k) 
    {
     
        unordered_map<int,int> MAP;//映射关系
        MAP[0]=1; //表示没有添加任何元素
        int sum=0,result=0;
        for(int item:nums)
        {
     
            sum+=item;
            if(MAP.find(sum-k)!=MAP.end()) result+=MAP[sum-k];
            MAP[sum]++;
        }
        return result;
    }
};

209. 长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的连续子数组，并返回其长度。如果不存在符合条件的连续子数组，返回 0。

示例:

输入: s = 7, nums = [2,3,1,2,4,3]
输出: 2
解释: 子数组 [4,3] 是该条件下的长度最小的连续子数组。

分析：

方法一：双指针法，动态维护区间

求符合条件的最小的连续子区间，可以采用双指针法，动态维护一个符合条件的区间。

• 设置两个指针，left和right，分别标记当前维护的区间的左端和右端
• 如果当前区间和小于s,则右移right，直至大于等于s
• 如果当前区间和大于s，则右移left，直至小于等于s (这个过程需要记录最小的区间长度)
• 直至right遍历至数组结束，返回过程中记录的最小区间长度即可

该算法由于至多遍历两边数组，故时间复杂度是 $O(n)$

class Solution {
     
public:
    int minSubArrayLen(int s, vector<int>& nums) 
	{
     
		int left=0,right=0;//双指针,维护一个大于等于s的区间
		int ans=INT_MAX,sum=0;
		for(right=0;right<nums.size();right++)
		{
     
			sum+=nums[right];
			while(sum>=s) //如果当前的sum大于s,右移左指针，直至该条件不成立 
			{
     
				ans=min(ans,right-left+1);//刷新长度
				sum-=nums[left++];	//左指针右移,刷新sum 
			}	
		}
		return ans==INT_MAX?0:ans;	
    }
};

方法二：前缀和，二分查找

该方法思路主要是求子数组的和问题，通常都可以采用前缀和进行简化，将数组的和转化为前缀和数组中两个值的差。该题中，由于数字都是正整数，因此前缀和是单调递增的，故可以每次确定一个 $sum[i]$的位置，然后利用二分查找的方法找左侧 $sum[i]-s$ 的位置。

因为需要遍历数组，每个位置都需要进行二分查找，因此总的时间复杂度是 $O(nlogn)$

class Solution {
     
public:
    int minSubArrayLen(int s, vector<int>& nums) 
	{
     
		vector<int> sum(nums.size()+1);
        sum[0]=0;  //注意将sum[0]初始化为0
        if(nums.size()==0) 
            return 0;
		for(int i=1;i<sum.size();i++)
			sum[i]=sum[i-1]+nums[i-1];
		int ans=INT_MAX;
		for(int i=0;i<sum.size();i++)
		{
     
			//lowerbound_bound返回大于等于val的第一个元素位置
            if(sum[i]+s>sum[sum.size()-1]) 
                break;
            //找到大于等于sum[i]+s的位置
			int pos=lower_bound(sum.begin(),sum.end(),sum[i]+s)-sum.begin();
			ans=min(ans,pos-i);  //由于多了一个sum[0],因此计算长度时实际上是pos-i即可
		}
		return ans==INT_MAX?0:ans;	
    }
};

713. 乘积小于K的子数组

给定一个正整数数组 nums。

找出该数组内乘积小于 k 的连续的子数组的个数。

示例 1:
输入: nums = [10,5,2,6], k = 100
输出: 8
解释: 8个乘积小于100的子数组分别为: [10], [5], [2], [6], [10,5], [5,2], [2,6], [5,2,6]。
需要注意的是 [10,5,2] 并不是乘积小于100的子数组。

分析：双指针法，动态维护符合要求的区间。

设立两个指针left和right，分别标记当前维护的区间的头和尾。

• 向右移动right，动态改变区间乘积
• 如果当前区间乘积小于k，也就说明增添的这个新元素仍使得区间符合要求，增添一个新元素会增加right+left-1个符合要求的连续子数组(考虑，增添的连续子数组为：包含新增添的这个元素，然后从区间左边第一个开始至新元素、第二个至新元素、直至仅剩新元素一个。)
• 如果当前区间乘积大于等于k，就需要移动左节点，动态更新区间的乘积，直至小于k为止
• 重复上述操作，直至right遍历至结尾

class Solution {
     
public:
    int numSubarrayProductLessThanK(vector<int>& nums, int k) 
    {
     
        if(k<=1) return 0;
        int left=0,right=0;
        int mul=1,ans=0;
        while(right<nums.size())
        {
     
            mul*=nums[right];  //动态维护mul
            while(mul>=k)  //移动左指针
            {
     
                mul/=nums[left++];  //动态维护mul
            }
            ans+=right-left+1;  //增加的符合要求的区间数量
            right++;
        }
        return ans;
    }
};

1248. 统计「优美子数组」

给你一个整数数组 nums 和一个整数 k。

如果某个 连续 子数组中恰好有 k 个奇数数字，我们就认为这个子数组是「优美子数组」。

请返回这个数组中「优美子数组」的数目。

示例 1：
输入：nums = [1,1,2,1,1], k = 3
输出：2
解释：包含 3 个奇数的子数组是 [1,1,2,1] 和 [1,2,1,1] 。

示例 2：
输入：nums = [2,4,6], k = 1
输出：0
解释：数列中不包含任何奇数，所以不存在优美子数组。

示例 3：
输入：nums = [2,2,2,1,2,2,1,2,2,2], k = 2
输出：16

分析：优美子数组是指含有指定的奇数数字的连续子数组，因此在此可以采用滑动窗口法即双指针法。

• 设置一个数组，用来存储奇数的位置(这样也方便记录相邻奇数间的偶数个数)
• 在数组的头和尾插入一个奇数，即-1和nums.size()的位置，为了避免无限循环和遗漏末尾
• 每遇到一个奇数就将奇数位置放入数组
• 当满足要求时，区间可以通过设置的数组知道，在不违反要求的前提下当前区间可以进行拓展，即让区间左端点向左移动，区间右端点向右移动，直至不能拓展，就是记录左侧有多少偶数L，右侧有多少偶数R，包含这k个奇数的区间实际上有 (L+1)*(R+1)个,(实现时我直接用了索引差，就不需要再加1)，然后右移左端点至下一个奇数，继续遍历

class Solution {
     
public:
    int numberOfSubarrays(vector<int>& nums, int k)
    {
     
        vector<int> odd_pos; //记录奇数的位置 
        int ans = 0;
        int left = 1; //记录左侧 
        odd_pos.push_back(-1); //等价于在nums的最左侧增加一个奇数，方便判断 
        for (int right = 0; right <= nums.size(); right++)
        {
     
            if (right == nums.size()||(nums[right] & 1))  //末尾处也加一个奇数
            {
     
                odd_pos.push_back(right);
            }

            if (odd_pos.size() - left > k) 
            {
     
                int L = odd_pos[left] - odd_pos[left - 1];
                int R = right - odd_pos[odd_pos.size() - 2];
                ans += L * R;
                left++;
            }
        }
        return ans;
    }
};

581. 最短无序连续子数组

给定一个整数数组，你需要寻找一个连续的子数组，如果对这个子数组进行升序排序，那么整个数组都会变为升序排序。

你找到的子数组应是最短的，请输出它的长度。

示例 1:
输入: [2, 6, 4, 8, 10, 9, 15]
输出: 5
解释: 你只需要对 [6, 4, 8, 10, 9] 进行升序排序，那么整个表都会变为升序排序。

方法一：排序法

利用快排将数组排序，比较排序后的数组与原始数组第一个和最后一个不同的位置，这两个位置就是需要整理的最短无序连续子数组。

时间复杂度为 $O(nlogn)$ 空间复杂度为 $O(n)$

class Solution {
     
public:
    int findUnsortedSubarray(vector<int>& nums) 
    {
     
        vector<int> sort_nums=nums;
        sort(sort_nums.begin(),sort_nums.end());
        int left=-1,right=-1;
        for(int i=0;i<nums.size();i++)
        {
     
            if(left==-1&&sort_nums[i]!=nums[i])
                left=i;
            if(sort_nums[i]!=nums[i])
                right=i;
        }
        return left==-1?0:(right-left+1);
    }
};

方法二：定位法

该数组大致是这样的，首先是升序子列，然后是一段子列，然后是升序子列。因此，要定位乱序的起始位置，就需要找到这之间的数组的最小值应该在的位置，最大值应该在的位置。即无序子数组中最小元素的正确位置可以决定左边界，最大元素的正确位置可以决定右边界。因此通过多遍遍历的方式，先找到最小元素最大元素，然后再次找到其应该在的位置。

时间复杂度 $O(n)$ 空间复杂度 $O(1)$

class Solution {
     
public:
    int findUnsortedSubarray(vector<int>& nums) 
    {
     
        if(nums.size()==0||nums.size()==1) return 0;
        int left=0,right=0;
        for(int i=1;i<nums.size();i++) //确定左边界
        {
     
            if(nums[i]<nums[i-1])
            {
     
                left=i-1;
                break;
            }
        }
        for(int i=nums.size()-2;i>=0;i--) //确定右边界
        {
     
            if(nums[i]>nums[i+1])
            {
     
                right=i+1;
                break;
            }
        }
        if(left==right) return 0;
        int MIN=INT_MAX,MAX=INT_MIN;
        for(int i=left;i<=right;i++) //找到最小值最大值
        {
     
            MIN=min(MIN,nums[i]);
            MAX=max(MAX,nums[i]);
        }
        //找到最小值最大值的应该的位置
        //用left和right记录
        for(int i=0;i<nums.size();i++)
        {
     
            if(MIN<nums[i])
            {
     
                left=i;
                break;
            }
        }
        for(int i=nums.size()-1;i>=0;i--)
        {
     
            if(MAX>nums[i])
            {
     
                right=i;
                break;
            }
        }
        return right-left+1;
    }
};