统计m个奇数的子数组的数量

在程序开发中，我们经常需要对一个数组进行统计、分析等操作，其中一个常见问题是统计其中包含m个奇数的子数组的数量。

问题描述

给定一个整数数组 nums 和一个整数 m，统计该数组中包含恰好 m 个奇数的子数组的数量。

例如，给定数组 nums = [1, 2, 3, 4, 5] 和 m = 2，其中包含恰好 2 个奇数的子数组为 [1, 2, 3], [1, 2, 3, 4, 5], [3, 4, 5]，共计 3 个。

解法一：暴力枚举

最朴素的想法，就是枚举所有的子数组，并统计其中奇数的个数。时间复杂度为 O(n^3)，显然过高，无法通过较大的数据测试。

def countSubarrays(nums, m):
    count = 0
    n = len(nums)
    for i in range(n):
        for j in range(i, n):
            odd_count = 0
            for k in range(i, j + 1):
                if nums[k] % 2 == 1:
                    odd_count += 1
            if odd_count == m:
                count += 1
    return count

解法二：前缀和 + 离散化

利用前缀和优化暴力枚举，可以将时间复杂度优化至 O(n^2)。具体思路是，先求出原数组的前缀和数组，然后用前缀和计算任意子数组的和。

具体实现中，需要对前缀和数组中的所有奇数进行离散化处理，并用哈希表记录奇数和其出现次数的对应关系。

from collections import defaultdict

def countSubarrays(nums, m):
    count, n = 0, len(nums)
    prefix_sum, odd_count = [0] * (n + 1), [0] * (n + 1)
    for i in range(n):
        prefix_sum[i + 1] = prefix_sum[i] + nums[i]
        odd_count[i + 1] = odd_count[i] + (nums[i] & 1)
        
    odd_dict = defaultdict(int)
    for odd in odd_count:
        odd_dict[odd] += 1
        
    for odd in odd_dict:
        if odd - m in odd_dict:
            count += odd_dict[odd] * odd_dict[odd - m]
            
    return count

解法三：双指针

最优解法是利用双指针算法，在一次遍历中计算出所有子数组中奇数的个数。具体思路是，用两个指针 i 和 j 分别指向数组头和尾，同时维护两个变量 odd_count 和 count，前者表示当前子数组中奇数的个数，后者表示目前满足条件的子数组个数。

如果 odd_count == m，则 count 加一，此时将 i 向右移动一位，并且奇数的个数减一；如果 odd_count < m，则将 j 向右移动一位，并且奇数的个数加一；否则将 i 向右移动一位，并将奇数的个数减一。

该算法总时间复杂度为 O(n)，空间复杂度为 O(1)，是本题的最优解。

def countSubarrays(nums, m):
    i, j, count, odd_count = 0, 0, 0, 0
    while j < len(nums):
        if nums[j] % 2 == 1:
            odd_count += 1
            
        while i <= j and odd_count > m:
            if nums[i] % 2 == 1:
                odd_count -= 1
            i += 1
            
        if odd_count == m:
        count += 1
            
        j += 1
            
    return count

总结

本题属于数组和双指针的典型应用之一，分别利用前缀和、离散化和双指针等算法，可以将时间复杂度从 O(n^3) 优化至 O(n)。在实际开发中，可以根据实际情况选择不同的算法进行优化，以获得更高的效率。