滑动窗口题目：统计「优美子数组」

题目

标题和出处

标题：统计「优美子数组」

出处：1248. 统计「优美子数组」

难度

5 级

题目描述

要求

给定一个整数数组 $\text{nums}$ 和一个整数 $\text{k}$。如果一个连续子数组中恰好有 $\text{k}$ 个奇数，则该子数组是「优美子数组」。

返回「优美子数组」的数目。

示例

示例 1：

输入：$\text{nums = [1,1,2,1,1], k = 3}$
输出：$\text{2}$
解释：包含 $\text{3}$ 个奇数的子数组是 $\text{[1,1,2,1]}$ 和 $\text{[1,2,1,1]}$。

示例 2：

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

示例 3：

输入：$\text{nums = [2,2,2,1,2,2,1,2,2,2], k = 2}$
输出：$\text{16}$

数据范围

• $\text{1}\le \text{nums.length}\le \text{50000}$
• $\text{1}\le \text{nums[i]}\le {\text{10}}^{\text{5}}$
• $\text{1}\le \text{k}\le \text{nums.length}$

解法一

思路和算法

如果数组 $\text{nums}$ 的下标范围 $[x,y]$ 的子数组中有 $k$ 个奇数，且 $\text{nums}[x]$ 和 $\text{nums}[y]$ 都是奇数，则在不引入新的奇数的情况下，将子数组的开始下标向左移动和将子数组的结束下标向右移动之后，子数组中仍有 $k$ 个奇数。假设 $\text{nums}[x]$ 左侧有连续 $\text{left}$ 个偶数，$\text{nums}[y]$ 右侧有连续 $\text{right}$ 个偶数，则包含 $k$ 个奇数且这 $k$ 个奇数都在下标范围 $[x,y]$ 中的子数组个数是 $(\text{left}+1)\times (\text{right}+1)$。

对于长度为 $n$ 的数组 $\text{nums}$，假设 $\text{nums}[-1]$ 和 $\text{nums}[n]$ 都是奇数，由于 $0\le x\le y<n$，因此 $\text{nums}[x]$ 左侧和 $\text{nums}[y]$ 右侧一定有奇数。假设 $\text{nums}[x]$ 左侧距离最近的奇数位于下标 $x^{\prime }$，$\text{nums}[y]$ 右侧距离最近的奇数位于下标 $y^{\prime }$，则有 $\text{left}+1=x-x^{\prime }$，$\text{right}+1=y^{\prime }-y$。记 $\text{leftCount}=x-x^{\prime }$，$\text{rightCount}=y^{\prime }-y$，则包含 $k$ 个奇数且这 $k$ 个奇数都在下标范围 $[x,y]$ 中的子数组个数是 $\text{leftCount}\times \text{rightCount}$。

根据上述分析，可以创建一个数组 $\text{oddIndices}$ 记录数组 $\text{nums}$ 中的所有奇数所在下标，包括下标 $-1$ 和下标 $n$。用 $\text{oddCount}$ 表示数组 $\text{oddIndices}$ 的长度，当 $0<i\le j<\text{oddCount}-1$ 且 $j-i+1=k$ 时，数组 $\text{oddIndices}$ 中的下标范围 $[i,j]$ 的子数组表示数组 $\text{nums}$ 的一个包含 $k$ 个奇数的子数组，将 $(\text{oddIndices}[i]-\text{oddIndices}[i-1])\times (\text{oddIndices}[j+1]-\text{oddIndices}[j])$ 加到答案中。

遍历结束之后，即可得到「优美子数组」的数目。

代码

class Solution {
    public int numberOfSubarrays(int[] nums, int k) {
        int subarrays = 0;
        List<Integer> oddIndices = new ArrayList<Integer>();
        oddIndices.add(-1);
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            if (nums[i] % 2 == 1) {
                oddIndices.add(i);
            }
        }
        oddIndices.add(n);
        int oddCount = oddIndices.size();
        for (int i = 1, j = k; j < oddCount - 1; i++, j++) {
            int leftCount = oddIndices.get(i) - oddIndices.get(i - 1);
            int rightCount = oddIndices.get(j + 1) - oddIndices.get(j);
            subarrays += leftCount * rightCount;
        }
        return subarrays;
    }
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。需要创建长度为 $O(n)$ 的数组 $\text{oddIndices}$ 记录数组 $\text{nums}$ 中的所有奇数所在下标，然后使用大小为 $k$ 的定长滑动窗口遍历数组 $\text{oddIndices}$ 统计「优美子数组」的数目。

• 空间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。需要创建长度为 $O(n)$ 的数组 $\text{oddIndices}$ 记录数组 $\text{nums}$ 中的所有奇数所在下标。

解法二

思路和算法

解法一创建新数组记录所有奇数所在下标，然后在新数组上使用定长滑动窗口统计「优美子数组」的数目。也可以在数组 $\text{nums}$ 上使用变长滑动窗口统计「优美子数组」的数目。

用 $[\text{start},\text{end}]$ 表示滑动窗口，初始时 $\text{start}=\text{end}=0$。将滑动窗口的右端点 $\text{end}$ 向右移动，直到滑动窗口中包含 $k$ 个奇数（确保 $\text{nums}[\text{end}]$ 是奇数）或者 $\text{end}$ 超出数组下标范围。

当滑动窗口中包含 $k$ 个奇数时，需要计算包含 $k$ 个奇数且这 $k$ 个奇数都在下标范围 $[\text{start},\text{end}]$ 中的子数组个数，计算方法如下。

1. 当 $\text{nums}[\text{start}]$ 是偶数时，将 $\text{start}$ 向右移动，直到 $\text{start}$ 是奇数，然后将 $\text{start}$ 再次向右移动一位，将 $\text{start}$ 的移动次数记为 $\text{leftCount}$。

2. 将 $\text{end}$ 向右移动一位，当 $\text{end}$ 未超出数组下标范围且 $\text{nums}[\text{end}]$ 是偶数时，将 $\text{end}$ 向右移动，直到 $\text{end}$ 超出数组下标范围或 $\text{nums}[\text{end}]$ 是奇数，将 $\text{end}$ 的移动次数记为 $\text{rightCount}$。

3. 将 $\text{leftCount}\times \text{rightCount}$ 加到答案中。

当 $\text{end}$ 超出数组下标范围时，遍历结束，此时即可得到「优美子数组」的数目。

上述过程中，每一轮 $\text{start}$ 向右移动时都经过一个奇数，然后停留在该奇数右边的相邻元素，每一轮 $\text{end}$ 向右移动时都是从一个奇数移动到下一个奇数（这里将超出数组下标范围的元素也看成奇数）。因此，每次 $\text{start}$ 和 $\text{end}$ 的移动次数都是数组 $\text{nums}$ 中的两个相邻奇数之间的距离，且确保子数组中包含 $k$ 个奇数。

代码

class Solution {
    public int numberOfSubarrays(int[] nums, int k) {
        int oddCount = 0;
        int start = 0, end = 0;
        int n = nums.length;
        while (end < n) {
            if (nums[end] % 2 == 1) {
                oddCount++;
                if (oddCount == k) {
                    break;
                }
            }
            end++;
        }
        int subarrays = 0;
        while (end < n) {
            int leftCount = 1, rightCount = 1;
            while (nums[start] % 2 == 0) {
                leftCount++;
                start++;
            }
            start++;
            end++;
            while (end < n && nums[end] % 2 == 0) {
                rightCount++;
                end++;
            }
            subarrays += leftCount * rightCount;
        }
        return subarrays;
    }
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。滑动窗口的左右端点最多各遍历数组 $\text{nums}$ 一次。

• 空间复杂度：$O(1)$。