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

---

提示 1

After replacing each even by zero and every odd by one can we use prefix sum to find answer ?

---

提示 2

Can we use two pointers to count number of sub-arrays ?

---

提示 3

Can we store indices of odd numbers and for each k indices count number of sub-arrays contains them ? ( 我们能否存储奇数索引，并为每 k 个索引计算包含它们的子数组的数目？)

解法1：数学

这个题目中偶数没有用，我们可以单独建立一个 odd 数组来记录第 i 个奇数的下标。

我们可以枚举奇数，假设当前枚举到第 i 个，那么 [odd[i],odd[i+k−1]] 这个子数组就恰好包含 k 个奇数。由于奇数和奇数间存在偶数，所以一定存在其他子数组 [l,r] 满足 [l,r] 包含 [odd[i],odd[i+k−1]] 且 [l,r] 里的奇数个数为 k 个，那么这个需要怎么统计呢？

由于我们已经记录了每个奇数的下标，第 i 个奇数的前一个奇数的下标为 odd[i−1]，也就是说 (odd[i−1],odd[i]) 间的数都为偶数。同理可得 (odd[i+k−1],odd[i+k]) 间的数也都为偶数。那么满足 l∈(odd[i−1],odd[i]] 且 r∈[odd[i+k−1],odd[i+k]) 条件的子数组 [l,r] 包含 [odd[i],odd[i+k−1] 且 [l,r] 里的奇数个数为 k 个。因此对于第 i 个奇数，它对答案的贡献为符合条件的 [l,r] 的个数，即：

(odd[i]−odd[i−1])×(odd[i+k]−odd[i+k−1]) 

我们只要遍历一遍 odd 数组即可求得最后的答案，注意边界的处理。

class Solution {
    public int numberOfSubarrays(int[] nums, int k) {
        int n = nums.length;
        // odd数组记录第 i 个奇数的下标
        int[] odd = new int[n + 2];
        int count = 0;
        int ans = 0;
        for (int i = 0; i < n; i++) {
            if (nums[i] % 2 == 0) {
                nums[i] = 0;
            } else {
                nums[i] = 1;
                count++;
                odd[count] = i;
            }
        }
        if (count < k) {
            return 0;
        }
        odd[0] = -1;
        odd[count + 1] = n;
        for (int i = 1; i + k <= count + 1; i++) {
            // nums[odd[i]..odd[i + k - 1]] 恰好包含 k 个奇数
            // nums[l,r]包含 k 个奇数,l属于(odd[i - 1], odd[i])，r属于(odd[i + k - 1], odd[i + k])
            // (odd[i] - odd[i - 1]) * (odd[i + k] - odd[i + k - 1])为符合条件的子数组[l,r]的个数
            ans += (odd[i] - odd[i - 1]) * (odd[i + k] - odd[i + k - 1]);
        }
        return ans;
    }
}

复杂度分析 

• 时间复杂度：O(n)，n 是  数组 nums 的长度。
• 空间复杂度：O(n)，n 是  数组 nums  的长度。

解法2：前缀和 + 哈希表

需要注意的是，从左往右一边更新一边计算的时候，已经保证了map[ prefixSum[ i ] − k ]里记录的 prefixSum[ j ] 的下标范围是 0 ≤ j ≤ i 。同时，由于prefixSum[i] 的计算只与前一项的答案有关，因此我们可以不用建立 prefixSum 数组，直接用 prefixSum 变量来记录 prefixSum[ i +1] 的答案即可。

相同解法的题   LeetCode 560. 和为 K 的子数组-CSDN博客  LeetCode 930. 和相同的二元子数组-CSDN博客 

 相似题型：LeetCode 2563. 统计公平数对的数目-CSDN博客

class Solution {
    public int numberOfSubarrays(int[] nums, int k) {
        int n = nums.length;
        int preSum = 0;
        int count = 0;
        int ans = 0;
        Map<Integer, Integer> map = new HashMap<>();
        map.put(0, 1);
        for (int i = 0; i < n; i++) {
            if (nums[i] % 2 == 0) {
                nums[i] = 0;
            } else {
                nums[i] = 1;
                count++;
            }
        }
        if (count < k) {
            return 0;
        }
        for (int i = 0; i < n; i++) {
            // sum(nums[j..i]) = k 即 nums[j..i]的奇数数目 = k, j <= i
            // preSum[i + 1] - preSum[j] = k
            // 对于每个i，找到满足preSum[i + 1] - k = preSum[j]的preSum[j]的个数
            preSum += nums[i];
            ans += map.getOrDefault(preSum - k, 0);
            map.merge(preSum, 1, Integer::sum);
        }
        return ans;
    }
}

复杂度分析 

• 时间复杂度：O(n)，n 是  数组 nums 的长度。
• 空间复杂度：O(n)，n 是  数组 nums  的长度。最坏情况下，哈希表有 n 个不同的键值，因此需要 O(n) 的空间复杂度。

Q：为什么要把 map(0, 1) 也加到哈希表中？

A：要想把任意子数组都表示成两个前缀和的差，必须添加 map(0, 1) ，否则当子数组是前缀时，没法减去一个数。

解法3：前缀和 

此解法和解法2基本相同

class Solution {
    public int numberOfSubarrays(int[] nums, int k) {
        int n = nums.length;
        int preSum = 0;
        int count = 0;
        int ans = 0;
        int[] map = new int[n + 1];
        for (int i = 0; i < n; i++) {
            if (nums[i] % 2 == 0) {
                nums[i] = 0;
            } else {
                nums[i] = 1;
                count++;
            }
        }
        if (count < k) {
            return 0;
        }
        map[0] = 1;
        for (int i = 0; i < n; i++) {
            // sum(nums[j..i]) = k 即 nums[j..i] 有 k 个奇数，preSum[i + 1] - preSum[j] = k
            // 对于每个i，找到满足 preSum[i + 1] - k = preSum[j] 的 preSum[j] 的个数
            preSum += nums[i];
            if (preSum - k >= 0) {
                ans += map[preSum - k];
            }
            map[preSum]++;
        }
        return ans;
    }
}

复杂度分析 

• 时间复杂度：O(n)，n 是  数组 nums 的长度。
• 空间复杂度：O(n)，n 是  数组 nums  的长度。