Leetcode之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

 

代码：

方法一——超时版滑动窗口法，时间复杂度O(n^2)：

class Solution {
public:
    int subarraysWithKDistinct(vector<int>& A, int K) {
        int length=A.size();
    map<int,int> m;
    for(int i=1;i<=length;i++){
        m[i]=0;
    }
    int l=0,r=0,count=0,total=0;

    while(r<length){
        if(m[A[r]]==0){
            count+=1;
            m[A[r]]+=1;
        }else{
            m[A[r]]+=1;
        }
        int temp=count;
        l=0;
        map<int,int> im=m;
        while(temp>=K){
            if(temp==K){
                total+=1;
            }
            if(im[A[l]]==1){
                temp-=1;
                im[A[l]]-=1;
            }else{
                im[A[l]]-=1;
            }
            l++;
        }
        r++;
    }
    return total;
    }
};

想法：用滑动窗口法的思路，但是和普通的滑动窗口法略有不同，普通的滑动窗口法不包含包含的关系，但是这里的滑动窗口法需要包含包含关系；所以，每次循环r，l都从0开始循环，都复制一遍原来的map字典；然后进行判断；下面介绍一下每次循环的过程，首先判断m[A[r]]，如果m[A[r]]==0，那么count和m[A[r]]都+1，否则只有m[A[r]]+1；然后将l置为0，复制m，temp=count; 从l=0开始，不断判断temp是否等于K，如果等于K，那么total+1，如果im[A[r]]==1,那么temp-=1,im[A[l]]-=1; 否则只有im[A[i]]-=1；最后r++，进入下一次循环；这样可以保证对于每一个子数组都检查得到；

方法二——另一种不超时的滑动窗口法，时间复杂度O(n^2)：

int subarraysWithKDistinct(vector<int>& A, int K) {
    int n=A.size();
    vector<int> num1(n+1),num2(n+1);
    int tot1=0,tot2=0;
    int left1=0,left2=0,right=0;
    int ret=0;

    while(right<n){
        if(!num1[A[right]]){
            tot1++;
        }
        num1[A[right]]++;
        if(!num2[A[right]]){
            tot2++;
        }
        num2[A[right]]++;
        while(tot1>K){
            num1[A[left1]]--;
            if(!num1[A[left1]])tot1--;
            left1++;
        }
        while(tot2>K-1){
            num2[A[left2]]--;
            if(!num2[A[left2]])tot2--;
            left2++;
        }
        ret+=left2-left1;
        right++;
    }

    return ret;
}

思路：我们容易发现，对于任意一个右端点，可能存在一系列左端点与其对应，满足两端点所指区间对应的字数组内恰有K个不同的整数，因此可能有O(n^2)个子数组满足条件。因此无法暴力解决该题。分析这些左端点，我们可以证明：对于任意一个右端点，能够与其对应的左端点们必然相邻。证明非常直观，假设区间[l1,r]和[l2,r]为满足条件的数组(不失一般性，设l1<l2)。现在我们设存在一个l满足l1<=l<=l2,那么区间[l1,r]作为[l1,r]的子数组，其中的不同整数数量必然不超过K；同理，区间[l,r]作为[l2,r]的父数组，其中的不同整数数量必然不少于K。那么可知区间[l,r]中的不同整数数量即为K。这样，我们就可以用一个区间[l1,l2]来代表能够与右端点r对应的左端点们。

同时，我们可以发现：当右端点向右移动时，左端点区间也同样向右移动。因为当我们在原有区间的右侧添加元素时，区间中的不同整数数量不会减少而只会不变或增加，因此我们需要在区间左侧删除一定元素，以保证区间内整数数量仍然为 K。

于是我们可以用滑动窗口解决本题，和普通的滑动窗口解法的不同之处在于，我们需要记录两个左指针left1与left2来表示左端点区间[left1,left2)。第一个左指针表示极大的包含K个不同整数的区间的左端点，第二个左指针则表示极大的包含K-1个不同整数的区间的左端点；