992. K 个不同整数的子数组

给定一个正整数数组 A，如果 A 的某个子数组中不同整数的个数恰好为 K，则称 A 的这个连续、不一定独立的子数组为好子数组。

（例如，[1,2,3,1,2] 中有 3 个不同的整数：1，2，以及 3。）

返回 A 中好子数组的数目。

示例 1：

输入：A = [1,2,1,2,3], K = 2
输出：7
解释：恰好由 2 个不同整数组成的子数组：[1,2], [2,1], [1,2], [2,3], [1,2,1], [2,1,2], [1,2,1,2].

示例 2：

输入：A = [1,2,1,3,4], K = 3
输出：3
解释：恰好由 3 个不同整数组成的子数组：[1,2,1,3], [2,1,3], [1,3,4].

提示：

• 1 <= A.length <= 20000
• 1 <= A[i] <= A.length
• 1 <= K <= A.length

解答

依然是滑动窗口，但这道题比较麻烦的是对于固定的右边界，可能有多个符合条件的左边界，暴力遍历肯定是不行的。我们可以想象一下，对于符合条件的若干左边界，彼此一定是相邻的（如果不相邻，即两个符合条件的左边界中间插入了其它数，显然矛盾），因此我们可以维护一个符合条件的最小左边界，再维护一个符合条件的最大左边界，两者的差值加一就是对于固定的右边界而言，符合条件的区间个数。

class Solution {
public:
    int subarraysWithKDistinct(vector<int>& A, int K) {
        // 维护两个左边界
        int left_min = 0, left_max = 0;
        int right = 0;
        // 记录两个窗口对应的数字出现次数
        unordered_map<int, int> map_min;
        unordered_map<int, int> map_max;

        int result = 0;
        while(right < A.size()){
            map_min[A[right]]++;
            map_max[A[right]]++;

            //分别移动两个左边界
            while(map_min.size() > K){
                map_min[A[left_min]]--;
                if(map_min[A[left_min]] == 0){
                    map_min.erase(A[left_min]);
                }
                left_min++;
            }
            
            while(map_max.size() > K - 1){
                map_max[A[left_max]]--;
                if(map_max[A[left_max]] == 0){
                    map_max.erase(A[left_max]);
                }
                left_max++;
            }
            result += left_max - left_min;
            right++;

        }
        return result;

    }
};