Subarrays with K Different Integers in C++

Suppose we have an array A of positive integers, we can call a good subarray (contiguous) of A, if the number of different integers in that subarray is exactly K. So, if the array is like [1,2,3,1,2] has 3 different integers: 1, 2, and 3. We have to find the number of good subarrays of A.

So, if the input is like [1,2,3,1,4] and K = 3, then the output will be 4, as it can form three subarrays with exactly four distinct integers, these are [1,2,3], [1,2,3,1], [2,3,1], [3,1,4].

To solve this, we will follow these steps −

• Define a function atMost(), this will take an array a and variable k,

• Define one set current

• j := 0, ans := 0, n := size of a

• Define one map m

• for initialize i := 0, when i < size of a, update (increase i by 1), do −

  • if m[a[i]] is zero, increase m[a[i]] by 1 then −

    • while k < 0, do −

      • if decrease m[a[j]] by 1 and m[a[i]] is zero, then −

        • (increase k by 1)

      • (increase j by 1)

  • x := ((i - j) + 1)

  • ans := ans + x

• return ans

• From the main method do the following −

• return atMost(a, k) - atMost(a, k - 1);

Let us see the following implementation to get better understanding −

Example

 Live Demo

#include <bits/stdc++.h>
using namespace std;
class Solution {
   public:
   int subarraysWithKDistinct(vector<int>& a, int k) {
      return atMost(a, k) - atMost(a, k - 1);
   }
   int atMost(vector <int>& a, int k){
      set <int> current;
      int j = 0;
      int ans = 0;
      int n = a.size();
      unordered_map <int, int> m;
      for(int i = 0; i < a.size(); i++){
         if(!m[a[i]]++) k--;
         while(k < 0){
            if(!--m[a[j]])
            k++;
            j++;
         }
         int x = ((i - j) + 1);
         ans += x;
      }
      return ans;
   }
};
main(){
   Solution ob;
   vector<int> v = {1,2,3,1,4};
   cout << (ob.subarraysWithKDistinct(v, 3));
}

Input

{1,2,3,1,4}, 3

Output

4