子数组处理+数学+滑动窗口+下标保存 leetcode 1248. 统计「优美子数组」

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.length <= 50000
1 <= nums[i] <= 10^5
1 <= k <= nums.length

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/count-number-of-nice-subarrays
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题
找到优美子数组——即奇数个数为K的数组，统计该类子数组的个数；

第一层：遍历，动态规划
遍历数组中每个数字，统计以该数字为头的优美子数组的个数，全部相加即可；
复杂度O（N^2），在N最大有50000的情况下爆炸；

class Solution {
public:
    int numberOfSubarrays(vector<int>& nums, int k) {
        
        int len=nums.size();
        int dp[len][len];
        
        for(int i=0;i<len;i++)
            {
                if(nums[i]%2!=0)
                    dp[i][i]=1;
                else dp[i][i]=0;
            for(int j=i+1;j<len;j++)
                {
                    if(nums[j]%2!=0)
                        dp[i][j]=dp[i][j-1]+1;
                    else 
                        dp[i][j]=dp[i][j-1];
                }
            }
        int cnt=0;
        for(int i=0;i<len;i++)  
            for(int j=i;j<len;j++)
                if(dp[i][j]==k) 
                    cnt++;

        return cnt; 
    }
};

第二层：遍历一次则每次只保存左边的奇数个数，计算得到结果
需要找到复杂度为O（N）的办法才能通过N=50000的测试点；

建立数组存放每个数字左边的奇数的个数（可用odd更新，不用记录）；
建立数组存放以下标0为起点的奇数个数为i的数组有多少个；
当i左边的奇数个数为K个时，所有以0为起点奇数个数为0的数组，i剪掉他们都还是奇数个数为K的数组；
故ans=cnt[0]；
当i左边的奇数个数为K+1个时，所有奇数个数为1的数组，i剪掉他们都为奇数个数为K的数组；
故ans=cnt[0]+[1];
所以遍历nums，得到整个数组的奇数个数，当odd>=K时，ans+=[odd-K]；
即把所有大于K的都加上去了；
最后的值即为nums中含有的含有奇数数为K个的数组个数；

初始化
nums[0]左边的奇数个数为0个；
resize函数，定义vector的大小

class Solution {
    vector <int > cnt;
public:
    int numberOfSubarrays(vector<int>& nums, int k) {
        int n=nums.size();
        cnt.resize(n+1,0);       //定义cnt大小
        int odd = 0,ans = 0;
        cnt[0]=1;    //表示奇数为0的组数有一组

        for(int i=0;i<n;++i){
            odd += nums[i]&1;       //到当前i为止的奇数个数
            if(odd>=k) ans+=cnt[odd-k];   
            //找到奇数个数为k的第一个数
            //则所有奇数个数为0的数到这里都变成k个；
            //所以ans+=cnt[odd-k]；
            //同理找到第一个奇数组数为k+1的数；
            //则所有左边奇数个数为1的数开始到左边奇数个数为k+1的数为止都是k个奇数；
            //即ans+=cnt[odd-k]
            cnt[odd]+=1;    //奇数为odd的组数+1
            //
        }
        return ans;
    }
};

第三层：数学方法计算，注意边界条件
保存每个奇数的下标在数组中；
因为需要一个数组含有K个奇数，则在奇数数组中隔k个奇数，把在外的偶数个数+1相乘，得到由这些奇数组成的最有子数组个数；

边界条件——odd[0]=-1，odd[N+1]=N;

(odd[i] - odd[i - 1])

得到odd[i]到上一个奇数中的偶数个数+1；

(odd[i + k] - odd[i + k - 1])

得到odd[i+K]（i后面第k个奇数）到下一个奇数中的偶数个数+1；
中间有K个奇数；
两者相乘即为这中间K个奇数构成的子数组个数；

遍历i，当i+K<=N+1时，计算每组相隔为k的奇数得到的子组数个数；
边界条件：
（若i+k-1中储存的下标为n-1，即最后一个数，则要乘的数目为n-（n-1）=1）
（若i=1时储存的下标为0，前面的乘数为1，故i=0时储存的下标为-1）

class Solution {
public:
    int numberOfSubarrays(vector<int>& nums, int k) {
        int n = (int)nums.size();
        int odd[n + 2], ans = 0, cnt = 0;
        for (int i = 0; i < n; ++i) {
            if (nums[i] & 1) odd[++cnt] = i;
        }
        odd[0] = -1, odd[++cnt] = n;
        //所有奇数下标保存在odd中
		//cnt为odd的计数
		// 0——-1有一个，    n——n-1有一个 
        for (int i = 1; i + k <= cnt; ++i) {
            ans += (odd[i] - odd[i - 1]) * (odd[i + k] - odd[i + k - 1]); 
        }
        return ans;
    }
};