[LeetCode] 992. Subarrays with K Different Integers

Given an integer array nums and an integer k, return the number of good subarrays of nums.

A good array is an array where the number of different integers in that array is exactly k.

• For example, [1,2,3,1,2] has 3 different integers: 1, 2, and 3.

A subarray is a contiguous part of an array.

Example 1:

Input: nums = [1,2,1,2,3], k = 2
Output: 7
Explanation: Subarrays formed with exactly 2 different integers: [1,2], [2,1], [1,2], [2,3], [1,2,1], [2,1,2], [1,2,1,2]

Example 2:

Input: nums = [1,2,1,3,4], k = 3
Output: 3
Explanation: Subarrays formed with exactly 3 different integers: [1,2,1,3], [2,1,3], [1,3,4].

Constraints:

• 1 <= nums.length <= 2 * 104
• 1 <= nums[i], k <= nums.length

K个不同整数的子数组。

给定一个正整数数组 nums和一个整数 k ，返回 num 中 「好子数组」 的数目。

如果 nums 的某个子数组中不同整数的个数恰好为 k，则称 nums 的这个连续、不一定不同的子数组为 「好子数组 」。

例如，[1,2,3,1,2] 中有 3 个不同的整数：1，2，以及 3。
子数组 是数组的 连续 部分。

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

题意是给定一个正整数数组 nums，如果 nums 的某个子数组中不同整数的个数恰好为 K，则称 nums 的这个连续、不一定独立的子数组为好子数组。返回 nums 中好子数组的数量。

思路依然是滑动窗口，但是这一题是没法直接套用76题的模板的，有一些变动（引用）。回忆前面做的滑动窗口的题目，有求过子数组里面最多K个不同元素的题（340），所以这个解法的思路是求子数组里面最多K个不同元素的子数组的数量 - 子数组里面最多K - 1个不同元素的子数组的数量。之前能用76题的模板解决的题，一般都是在某一个范围内最多或者最少有几个符合条件的区间或元素。但是这道题问的是恰好有多少个元素满足条件。

如果理解这个思路是怎么来的，代码就非常简单了，直接套用之前的模板即可。举个例子，如果请你找子数组里面最多3个不同元素的子数组的数量（A），和找子数组里面最多2个不同元素的子数组的数量（B），是不是两者的差就是子数组里面恰好有3个不同元素的数量呢？因为A里面一定包含了B的数量。

我这里提供 hashmap 和数组的两种实现，数组的实现速度会快很多。

时间O(n)

空间O(n)

Java hashmap实现，套用了诸多sliding window题目的模板

class Solution {
    public int subarraysWithKDistinct(int[] A, int K) {
        return helper(A, K) - helper(A, K - 1);
    }

    private int helper(int[] A, int K) {
        int start = 0;
        int end = 0;
        int res = 0;
        HashMap<Integer, Integer> map = new HashMap<>();
        while (end < A.length) {
            if (map.getOrDefault(A[end], 0) == 0) {
                K--;
            }
            map.put(A[end], map.getOrDefault(A[end], 0) + 1);
            end++;
            while (K < 0) {
                map.put(A[start], map.get(A[start]) - 1);
                if (map.get(A[start]) == 0) {
                    K++;
                }
                start++;
            }
            // 注意这里是累加，因为求的是子数组的数目的和
            res += end - start + 1;
        }
        return res;
    }
}

 

Java 数组实现

能用数组实现是因为题目里有这个条件，1 <= nums[i] <= A.length。否则是没法确定数组长度的。

class Solution {
    public int subarraysWithKDistinct(int[] nums, int k) {
        return helper(nums, k) - helper(nums, k - 1);
    }
    
    private int helper(int[] nums, int k) {
        int len = nums.length;
        int start = 0;
        int end = 0;
        int counter = 0;
        int res = 0;
        int[] map = new int[len + 1];
        while (end < nums.length) {
            if (map[nums[end]] == 0) {
                counter++;
            }
            map[nums[end]]++;
            end++;
            while (counter > k) {
                map[nums[start]]--;
                if (map[nums[start]] == 0) {
                    counter--;
                }
                start++;
            }
            // 注意这里是累加，因为求的是子数组的数目的和
            res += end - start;
        }
        return res;
    }
}

 

JavaScript实现

/**
 * @param {number[]} A
 * @param {number} K
 * @return {number}
 */
var subarraysWithKDistinct = function (A, K) {
    function atMostK(k) {
        let l = 0;
        let res = 0;
        const count = {};

        for (let r = 0; r < A.length; r++) {
            if (count[A[r]] == null) count[A[r]] = 0;
            if (count[A[r]] === 0) k--;
            count[A[r]]++;

            while (k < 0) {
                count[A[l]]--;
                if (count[A[l]] === 0) k++;
                l++;
            }
            // 注意这里是累加，因为求的是子数组的数目的和
            res += r - l + 1;
        }
        return res;
    }
    return atMostK(K) - atMostK(K - 1);
};

 

sliding window相关题目

LeetCode 题目总结