[leetcode每日一题2021/2/9]992. K 个不同整数的子数组

题目来源于leetcode，解法和思路仅代表个人观点。传送门。
难度：困难（逐渐困难也能写出来了）
时间：2h

题目

给定一个正整数数组 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

思路

双指针

为什么会想到双指针呢？
题目要求连续子数组，而且有恰好K个不同整数的要求。特别地，如果这个数组n的数都不同的话，那每个子数组长度都为K。

（制作动图2h小时，QAQ）

维护两个指针left和right，之间的不同元素个数在满足K的情况下，使用指针r往右边试探。之后left指针收缩，重复以上。
为什么不往左边试探？
会重复计算。从左往右一边就可以了。

代码

class Solution {
public:
    int subarraysWithKDistinct(vector<int>& A, int K) {
        int left = 0;
        int right = left;
        int n = A.size();
        unordered_map<int,int> map;
        //一段的不同元素
        int cnt = 0;
        int ans = 0;
        //维护一个恰好为K的段
        while(right <n){
            //一段，将这段的元素映射到map中
            if(!map.count(A[right])){
                //如果元素不存在
                cnt++;
            }
            map[A[right]]++;
            right++;
            //如果这段不同元素恰好为K
            /*
            * 1. 试探性的，向右延伸(临时右边界)
            * 2. 左边退出一个，(实际的左边界)
            * 3. 如果还有K个不同的元素，重复以上
            */
            while(cnt == K){
                //仅向右延伸
                int cntRight = 0;
                //右端点的后一个
                int r = right;
                while(r<n){
                    if(map.count(A[r])){
                        //如果存在
                        cntRight++;
                        r++;
                    }else{
                        break;
                    }
                }
                //计算总数
                ans += cntRight+1;

                //左端点退出 一个
                if(map[A[left]] == 1){
                    map.erase(A[left]);
                    cnt--;
                }else{
                    map[A[left]]--;
                }
                left++;
            }

        }
        return ans;
    }
};

算法复杂度

left指针和right指针不后退
时间复杂度： O(n)。
空间复杂度： O(n)。n为数组长度。