`* Python:`

`" "`

n, k = map(int, input().split())
x = list(map(int, input().split()))

deb = fin = count = resultat = 0
frequence = {}

while fin < n:
    frequence.setdefault(x[fin], 0)
    frequence[x[fin]] += 1

    count += (frequence[x[fin]] == 1)

    while count > k:
        frequence[x[deb]] -= 1
        count -= (frequence[x[deb]] == 0)
        deb += 1

    resultat += fin - deb + 1
    fin += 1

print(resultat)

--------------------------------------------

`" "`

`*` `x` gồm `n` phần tử

`*` Sử dụng hai con trỏ `deb` và $\texttt{fin}$ để chọn đoạn con bắt đầu từ chỉ số `deb` đến $\texttt{fin}$ của `x`

`*` Khi bắt đầu, cả hai con trỏ đều có giá trị bằng `0` (Dòng `3`)

`" "`

`*` Từ điển `frequence` dùng để đếm số lần xuất hiện của các phần tử trong `1` đoạn con

`*` Thực hiện khởi tạo giá trị mặc định `0` cho `1` khóa $\texttt{x[fin]}$ nếu nó chưa tồn tại trong từ điển `frequence`

`*` Tăng giá trị khóa $\texttt{x[fin]}$ trong từ điển `frequence` lên `1` đơn vị, mục đích là tăng số lần xuất hiện của phần tử $\texttt{x[fin]}$ trong đoạn con từ `deb` đến $\texttt{fin}$

`" "`

`*` Dòng `8`: Nếu $\texttt{x[fin]}$ xuất hiện trong đoạn con `1` lần thì tăng biến count lên 1 đơn vị. True tương đương `1` nên điều kiện $\texttt{(frequence[x[fin]] == 1)}$ đúng thì $\texttt{(frequence[x[fin]] == 1)}$ bằng `1`

`*` Kiểm tra `count > k` hay không còn có nghĩa kiểm tra `count` phần tử khác biệt `> k` hay không? Nếu đúng:

      `*` Giảm giá trị khóa $\texttt{x[deb]}$ trong từ điền `frequence` đi `1` đơn vị 

      `*` Nếu tần suất xuất hiện của `x[deb]` bằng `0` thì giảm count đi `1` đơn vị 

      `*` Dịch chuyển con trỏ đầu đoạn con sang phải $\texttt{(fin += 1)}$

      `*` Cộng độ dài đoạn con hiện tại vào $\texttt{resultat}$

      `*` Tăng biến $\texttt{fin}$ lên `1`, di chuyển con trỏ cuối đoạn con sang phải

      `*` Lặp lại cho tới khi `count` không lớn hơn `k` 

`" "`

`*` $\texttt{Tóm lại:}$

      `*` Con trỏ $\texttt{fin}$ được dịch chuyển từ trái sang phải

      `*` Con trỏ `deb` chỉ dịch chuyển khi cần thiết để đảm bảo đoạn con không chứa quá `k` phần tử phân biệt

      `*` Hai con trỏ này đại diện vị trí đầu và cuối của đoạn con

      `*` Mỗi lần dịch chuyển con trỏ thì số lần xuất hiện các phần tử trong đoạn con sẽ được cập nhật

      `*` Số lượng phần tử riêng biệt sẽ được cập nhật trong biến `count `

      `*` Cộng độ dài đoạn con hiện tại vào $\texttt{resultat}$. (Giả sử `k` là `4`, từ đoạn con có chỉ số `2` đến `7` có nhiều nhất là `k` phần tử riêng biệt, thì đoạn con từ `2` đến `3`, từ `2` đến `4`, từ `2` đến `5`, ..., từ `2` đến `7` cũng thõa mãn điều kiện nhiều nhất `k` phần tử riêng biệt, nên chúng ta sẽ cộng độ dài đoạn con hiện tại vào $\texttt{resultat}$)

`" "`

`*` $\texttt{Thuật toán được sử dụng:}$ Sliding Window thuộc kĩ thuật giải Two-pointers với hai con trỏ di chuyển độc lập, một con trỏ tăng dần, một con trỏ không đổi hoặc tăng dần.