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

leetcode 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 n = A.size();
        int leftBound = 0,rightBound = 0;
        int numsCount = 0,ans = 0;
        unordered_map<int,int> window;
        while(leftBound < n - K + 1){
            if(rightBound == n){
                window.clear();
                leftBound++;
                rightBound = leftBound;
                numsCount = 0;
                continue;
            }
            window[A[rightBound]]++;
            if(window[A[rightBound]] == 1){
                numsCount++;
            }
            if(numsCount == K){
                ans++;
            }else if(numsCount > K){
                window.clear();
                leftBound++;
                rightBound = leftBound;
                numsCount = 0;
                continue;
            }
            rightBound++;
        }
        return ans;
    }
};

题解

核心是一手：恰好转化为最多之差
最多包含K个不同整数的子数组，意即包含1,2…K个不同整数的子数组皆在此列。
如此，最多包含K个不同整数的子数组个数即恰好包含1,2…K个不同整数的子数组个数，而最多包含K-1个不同整数的子数组个数即恰好包含1,2…K-1个不同整数的子数组个数
两者相减即为恰好包含K个不同整数的子数组个数

class Solution {
public:
    //求最多包含K个不同整数的子数组个数，即恰好包含1,2,3...K-1,K个不同整数的子数组个数之和
    int atMostWithKDistinct(vector<int>& A,int K){
        int n = A.size();
        int leftBound = 0,rightBound = 0;
        int res = 0;
        int numsCount = 0;
        unordered_map<int,int> window;
        while(rightBound < n){
            window[A[rightBound]]++;
            if(window[A[rightBound]] == 1){
                numsCount++;
            }
            while(numsCount > K){
                window[A[leftBound]]--;
                if(window[A[leftBound]] == 0){
                    numsCount--;
                }
                leftBound++;
            }
            res += (rightBound - leftBound + 1);
            rightBound++;
        }   
        return res;
    }

    int subarraysWithKDistinct(vector<int>& A, int K) {
        //cout<<atMostWithKDistinct(A,K)<<' '<<atMostWithKDistinct(A,K-1);
        return atMostWithKDistinct(A,K) - atMostWithKDistinct(A,K-1);
    }
};

把中间求最多包含的代码单独拎出来看一下

while(rightBound < n){
   window[A[rightBound]]++;
    if(window[A[rightBound]] == 1){
        numsCount++;
    }
    while(numsCount > K){
        window[A[leftBound]]--;
        if(window[A[leftBound]] == 0){
            numsCount--;
        }
        leftBound++;
    }
    res += (rightBound - leftBound + 1);
    rightBound++;
}   

一旦右界纳入新的数字后数组还符合要求，答案便要加上(rightBound - leftBound + 1),其中的逻辑是:
譬如数组[1,2,3,4]，在纳入新的数字5后，新增的子数组便有[1,2,3,4,5],[2,3,4,5],[3,4,5],[4,5],[5]五种，恰好对应5的下标4减去1的下标0再加1。
而右界是不会左移的，所以不管左界如何右移，一定不会统计重复的答案