• 1 <= nums.length <= 2 × 10⁴
• 1 <= nums[i], k <= nums.length

Count the contiguous subarrays that hold exactly k distinct integers. Two things make this harder than the windows before it: we must count all of them (not find one best), and the condition is "exactly", which — as flagged back in Longest Substring Without Repeating Characters — is the case where the plain sliding window breaks.

A window works only when the rule is one-directional at the edges. "At most k distinct" is: adding a new value can only raise the distinct-count (toward invalid), removing on the left can only lower it (toward valid) — clean, one-directional, exactly the Fruit Into Baskets rule with a general k. But "exactly k" is not: extending right might keep you at k or jump to k+1, and shrinking might keep you at k or drop to k−1. There is no single left position where the window becomes valid, so left has nowhere fixed to sit. The brute force that recounts distinct values for every subarray is O(N²) and too slow for 2 × 10⁴.

Here is the trick that rescues it. Let atMost(x) = the number of subarrays with at most x distinct integers. Then:

Run the at-most-x-distinct window (the Fruit Into Baskets machine with 2 replaced by x). The counting step is the new idea: when the window [left..right] is valid, it contributes right - left + 1 new subarrays — namely every subarray that ends at right, since each start from left to right gives a valid window, and any start before left would exceed x distinct. Summing that over all right counts every at-most-x subarray exactly once.

def subarraysWithKDistinct(nums, k):
    def at_most(x):
        count = 0
        left = 0
        freq = {}
        for right in range(len(nums)):
            freq[nums[right]] = freq.get(nums[right], 0) + 1
            while len(freq) > x:
                freq[nums[left]] -= 1
                if freq[nums[left]] == 0:
                    del freq[nums[left]]
                left += 1
            count += right - left + 1     # subarrays ending at right with <= x distinct
        return count
    return at_most(k) - at_most(k - 1)

Total atMost(2) Subarrays: 6

Step 2: Calculate AtMost(1)
- AtMost(1) = 3 (subarrays: [1], [2], [1]).

Step 3: Subtract
- 6 - 3 = 3 (valid subarrays: [1, 2], [2, 1], [1, 2, 1]).