Given an array A of positive integers, call a (contiguous, not necessarily distinct) subarray of A good if the number of different integers in that subarray is exactly K.

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

Return the number of good subarrays of A.

 

Example 1:

Input: A = [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: A = [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].

 

Note:

1. 1 <= A.length <= 20000
2. 1 <= A[i] <= A.length
3. 1 <= K <= A.length

 

sliding window

time = O(n), space = O(n)

class Solution {
    public int subarraysWithKDistinct(int[] A, int K) {
        int[] map = new int[A.length + 1];
        int slow = 0, fast = 0, counter = 0, nsub = 0, res = 0;
        while(fast < A.length) {
            map[A[fast]]++;
            if(map[A[fast]] == 1) {
                counter++;
            }
            fast++;
            
            if(counter > K) {
                map[A[slow++]]--;
                counter--;
                nsub = 0;
            }
            
            if(counter == K) {
                while(map[A[slow]] > 1) {
                    map[A[slow++]]--;
                    nsub++;
                }
                res += nsub + 1;
            }
        }
        return res;
    }
}