题1248、统计「优美子数组」

一、题目¹

二、思路

我的最优解的思路：时间复杂度O(n)、空间复杂度O(n)
1、遍历整个数组，得到每两个奇数之间的偶数个数，存起来。
2、在遍历的时候统计遇到的奇数的个数，一旦等于k了，那就将这个区间的子数组的所有可能计算出来，添加在结果中，然后进入下一个数，如此往复。
3、计算k个奇数区间所有可能的子数组数量，子数组数量=区间首尾第一个奇数前/后连续的偶数个数加一之积。

大佬的思路也是这样，但是，就是优化了无数倍，每次循环少了好多不必要的处理。

双指针法：我找到的，目测有点麻烦，懒得弄了，不知道有没有更优的，思路如下。
使用两个指针，分别指向有k个连续奇数串的左右两端，然后重新计算两端的偶数个数，得到结果。

三、代码

import java.util.LinkedList;
import java.util.Queue;

/**
 * @author: 
 * @description: 统计「优美子数组」
 * @date: Created in 2020/4/21 15:30
 * @version: 1.0
 */
public class T1248 {

    public T1248(){

        //2
//        int k = 3;
//        int[] nums = { 1,1,2,1,1 };

        //0
//        int k = 1;
//        int[] nums = { 2,4,6 };
        //16
        int k = 2;
        int[] nums = { 2,2,2,1,2,2,1,2,2,2 };
        System.out.println( numberOfSubarrays(nums, k) );
        System.out.println( numberOfSubarrays1(nums, k) );

    }
    /**
     * 双指针法，使用两个指针分别指向子数组首尾奇数的位置
     *
     * @param nums 输入的数组
     * @param k 子数组中奇数的个数
     * @return 所有子数组的个数
     * */
    public int numberOfSubarrays(int[] nums, int k) {
        
    }

    /**
     * 大佬的最优解
     *
     * @param nums 输入的数组
     * @param k 子数组中奇数的个数
     * @return 所有子数组的个数
     * */
    public int numberOfSubarrays0(int[] nums, int k) {
        int[] times = new int[nums.length+1];
        int count = 0;
        int res = 0;

        times[0] = 1;
        for ( int num : nums ){
            count += num&1;
            times[count]++;
            if ( count>=k ){
                res += times[count-k];
            }
        }
        return res;
    }
    /**
     * 使用队列将每两个奇数之间的偶数个数存储起来，计算得到结果
     *
     * @param nums 输入的数组
     * @param k 子数组中奇数的个数
     * @return 所有子数组的个数
     * */
    public int numberOfSubarrays1(int[] nums, int k) {

        //用于存储每两个奇数之间的偶数数目的队列，每个值=(实际值+1)
        Queue<Integer> queue = new LinkedList<Integer>();

        //计数，判断nums中有没有k个奇数
        int count = 0;
        //结果
        int res = 0;
        //计算指针i之前的最后一个奇数到i之间有多少偶数
        int times = 1;

        for ( int num : nums ){

            //判断当前的数是奇数还是偶数
            //如果为偶数就将times加1，奇数进入下一步判断
            if ( num%2 != 0 ){
                //判断当前出现的奇数是否已经有k个了
                //如有就计算这k个奇数可以被分成多少个字数组，结果=两端的偶数个数加一的乘积
                //没有就将count加1
                if ( count == k ){
                    res += queue.poll() * times;
                }else {
                    count++;
                }
                //将这个奇数到上个奇数之间的偶数个数存入队列，并将times置为1
                queue.offer(times);
                times = 1;
            }else {
                times++;
            }

//            System.out.println( queue + "\t times:" + times + "\t i:" + i + "\t res:" + res + "\t count:" + count );
        }

        //计算最后一次结果，如果有的话
        if ( count == k ){
            res += queue.poll() * times;
        }
        return res;
    }

    public static void main(String[] args) {
        T1248 t1248 = new T1248();
    }
}

---

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